我有一个带有单个表的Hibernate数据库，看起来像：
PURCHASE_ID | PRODUCT_NAME | PURCHASE_DATE | PURCHASER_NAME | PRODUCT_CATEGORY
------------------------------------------------------------------------------
1 Notebook 09-07-2018 Bob Supplies
2 Notebook 09-06-2018 Bob Supplies
3 Pencil 09-06-2018 Bob Supplies
4 Tape 09-10-2018 Bob Supplies
5 Pencil 09-09-2018 Steve Supplies
6 Pencil 09-06-2018 Steve Supplies
7 Pencil 09-08-2018 Allen Supplies
根据其他一些限制，我只想退回最新购买的商品。例如：
List<Purchase> getNewestPurchasesFor(Array<String> productNames, Array<String> purchaserNames) { ... }
可以使用以下方式调用：
List<Purchase> purchases = getNewestPurchasesFor(["Notebook", "Pencil"], ["Bob", "Steve"]);
用英语，“给我鲍勃（Bob）或史蒂夫（Steve）购买笔记本或铅笔的最新款。”
并会提供：
PURCHASE_ID | PRODUCT_NAME | PURCHASE_DATE | PURCHASER_NAME
-----------------------------------------------------------
1 Notebook 09-07-2018 Bob
3 Pencil 09-06-2018 Bob
5 Pencil 09-09-2018 Steve
这就像在多个列上进行“不同”查找，或者是基于某些后排序组合列唯一键的“限制”，但我发现的所有示例均使用SELECT DISTINCT(PRODUCT_NAME, PURCHASER_NAME)仅获得这些列，而我需要使用以下格式：
from Purchases as entity where ...
以便返回完整的关系的模型类型。
当前，我的查询也向我返回了所有旧购买商品：
PURCHASE_ID | PRODUCT_NAME | PURCHASE_DATE | PURCHASER_NAME | PRODUCT_CATEGORY
------------------------------------------------------------------------------
1 Notebook 09-07-2018 Bob Supplies
2 Notebook 09-06-2018 Bob Supplies
3 Pencil 09-06-2018 Bob Supplies
5 Pencil 09-09-2018 Steve Supplies
6 Pencil 09-06-2018 Steve Supplies
对于重复购买，会导致性能下降。
我应该使用任何特殊的关键字来完成此操作吗？查询语言和SQL-fu不是我的强项。
编辑：
请注意，我目前正在使用Criteria API，并且希望继续使用。
Criteria criteria = session.createCriteria(Purchase.class);
criteria.addOrder(Order.desc("purchaseDate"));
// Product names
Criterion purchaseNameCriterion = Restrictions.or(productNames.stream().map(name -> Restrictions.eq("productName", name)).toArray(Criterion[]::new));
// Purchaser
Criterion purchaserCriterion = Restrictions.or(purchaserNames.stream().map(name -> Restrictions.eq("purchaser", name)).toArray(Criterion[]::new));
// Bundle the two together
criteria.add(Restrictions.and(purchaseNameCriterion, purchaserCriterion));
criteria.list(); // Gives the above results
如果我尝试使用不同的投影，则会出现错误：
ProjectionList projections = Projections.projectionList();
projections.add(Projections.property("productName"));
projections.add(Projections.property("purchaser"));
criteria.setProjection(Projections.distinct(projections));
结果：
17:08:39 ERROR Order by expression "THIS_.PURCHASE_DATE" must be in the result list in this case; SQL statement:
因为如上所述，当我想要的只是限制返回的内容时，添加一个投影/不同的列集似乎向Hibernate表示我想要这些列作为结果/返回值。根据唯一列值模型对象。
答案 0 :(得分：1)
首先，使用汇总查询来获取产品+购买者组合的最后购买日期。
将该查询用作与元组匹配的子选择：
from Puchases p
where (p.PRODUCT_NAME, p1.PURCHASER_NAME, p1.PURCHASE_DATE) in
(select PRODUCT_NAME, PURCHASER_NAME , max(PURCHASE_DATE)
from Purchases
where
PRODUCT_NAME in :productNames and
PURCHASER_NAME in :purchaserNames
group by PRODUCT_NAME, PURCHASER_NAME)
使用条件API以及Subqueries.propertiesIn，也可以实现相同的功能。
请参见Hibernate Criteria Query for multiple columns with IN clause and a subselect
如果保证您的PURCHASE_ID是“按时间顺序递增”，那么您可以在子选择中简单地使用max（PURCHASE_ID）。
答案 1 :(得分：0)
您可以使用@创建临时变量和表。我不确定如何创建数组。
declare @product1 = 'Pencil'
declare @product2 = 'Notebook'
declare @purchaser_name1 = 'Bob'
declare @purchaser_name2= 'Steve'
这应该获得每个客户/产品组合的最新购买日期
select
product_name, purchaser_name, max(purchase_date) as max_purchase_date
into @temp
from purchases with(nolock) where
product_name in (@product1,@product2) and
purchaser_name in (@purchaser_name1,@purchaser_name2)
group by product_name, purchaser_name
如果您需要回圈并获得ID，则可以重新加入购买以获取ID
select p.* from purchases p with(nolock)
inner join @temp t
on p.product_name = t.product_name
and p.purchaser_name = t.purchaser_name
and p.purchase_date = t.max_purchase_date
注意表名后的“ with（nolock）”。可能会对性能有所帮助。
答案 2 :(得分：0)
好吧，首先，我建立了只提取所请求记录的查询：
select p1.* from Purchase p1
join (
select
max(PURCHASE_DATE) as maxdate,
purchaser_name,
PRODUCT_NAME from Purchase
where
(product_name ='Notebook' or product_name = 'Pencil')
and purchaser_name in ('Bob','Steve')
group by
purchaser_name,
PRODUCT_NAME) p2
on p1.PURCHASE_DATE = p2.maxDate
and p1.PRODUCT_NAME = p2.PRODUCT_NAME
and p1.PURCHASER_NAME = p2.PURCHASER_NAME;
作为输出
PURCHASE_ID PRODUCT_NAME PURCHASE_DATE PURCHASER_NAME PRODUCT_CATEGORY
1 Notebook 2018-07-09 00:00:00.000 Bob Supplies
3 Pencil 2018-06-09 00:00:00.000 Bob Supplies
5 Pencil 2018-09-09 00:00:00.000 Steve Supplies
现在，我们可以在SQLQuery中转换该查询，并使用.setResultTransformer(Transformers.aliasToBean(Purchase.class))将其转换为bean。
请注意，我已将会话命名为yourSession，并进行相应的更改：
List<Purchase> list = yourSession.createSQLQuery(
"select p1.* from Purchase p1 "
+ " join ( "
+ " select "
+ " max(PURCHASE_DATE) as maxdate, "
+ " purchaser_name, "
+ " PRODUCT_NAME from Purchase "
+ " where "
+ " (product_name ='Notebook' or product_name = 'Pencil') " //this must be created dinamically based on your parameters
+ " and purchaser_name in ('Bob','Steve') " //and this too
+ " group by "
+ " purchaser_name, "
+ " PRODUCT_NAME) p2 "
+ " on p1.PURCHASE_DATE = p2.maxDate "
+ " and p1.PRODUCT_NAME = p2.PRODUCT_NAME "
+ " and p1.PURCHASER_NAME = p2.PURCHASER_NAME ")
.setResultTransformer(Transformers.aliasToBean(Purchase.class))
.list();
Ofc现在缺少的是在将代码包装到的方法中传递参数Notebook或Bob。我将构建一个根据参数列表的大小写条件的辅助方法。
由于我没有连接数据库的休眠状态，因此我可以随意编写代码，因此可能需要进行一些修复，但是一般的想法应该可以解决问题。
在没有SQLQuery的情况下，这样做困难得多，而且更难阅读：您需要的是将结果完整保存到bean中，这就是您要实现的目标。
答案 3 :(得分：0)
更新
要使用休眠条件，可以尝试使用子查询方法：
DetachedCriteria subQuery = DetachedCriteria.forClass(Purchase.class, "p2");
ProjectionList groupBy = Projections.projectionList();
groupBy.add(Projections.max("purchaseDate"));
groupBy.add(Projections.groupProperty("productName"));
groupBy.add(Projections.groupProperty("purchaserName"));
subQuery.setProjection(groupBy);
subQuery.add(Restrictions.in("productName", productNames));
subQuery.add(Restrictions.in("purchaserName", purchaserName));
Criteria purchase = session.createCriteria(Purchase.class, "p1");
purchase.add(Subqueries.propertiesIn(new String[] {"purchaseDate", "productName", "purchaserName"}, subQuery));
purchase.addOrder(Order.desc("purchaseDate"));
List<Purchase> p1 = purchase.list();
另一种方法是使用本机SQL：
SELECT p1.*
FROM purchase p1 LEFT JOIN purchase p2
ON (p1.purchaser_name = p2.purchaser_name
AND p1.product_name = p2.product_name
AND p1.purchase_date < p2.purchase_date)
WHERE p2.id IS NULL
AND p1.product_name IN ("Notebook", "Pencil")
AND p1.purchaser_name IN ("Bob", "Steve")
ORDER BY p1.product_name DESC
与子查询方法相比，此SQL给您带来显着的性能优势。
但是，它似乎无法翻译成Hibernate Criteria（因为Criteria需要实体之间的路径/映射）
答案 4 :(得分：0)
您好，我会为您提供一个非常简单的基于HQL的解决方案，并且不会带来太多魔术。解决方案是以下HQL查询：
select p.id, max(p.date) from Purchase p where p.productName in('notebook','pencil') and p.purchaseName in ('ob', 'Steve') group by p.productName ,p.purchaseName
获得记录的ID后，您可以按ID选择“实际产品”。
现在，您将认为此查询将返回整个表。不，它不会。支持服务器端游标的大多数现代数据库将仅向您返回指定数量的记录。
初始化查询后，下一步就是告诉它要返回多少结果：
Query query = query.setMaxResults(1)
query.setFetchSize();
query.scroll(ScrollMode.FORWARD_ONLY);
// here is a hint for MySQL
query.setMaxResults(100)
此查询使用正确，不会返回完整的表格！它将返回所告知的内容。
答案 5 :(得分：0)
尝试使用此代码。
SessionFactory sessFact = HibernateUtil.getSessionFactory();
Session session = sessFact.openSession();
Criteria criteria = session.createCriteria(Purchase.class);
ProjectionList projList = Projections.projectionList();
projList.add(Projections.groupProperty("purchaserName"));
projList.add(Projections.groupProperty("productName"));
projList.add(Projections.property("purchaseId"));
projList.add(Projections.property("productName"));
projList.add(Projections.max("purchaseDate"));
projList.add(Projections.property("purchaserName"));
criteria.setProjection(projList);
List<String> productList = new ArrayList<String>() {
{
add("Notebook");
add("Pencil");
}
};
List<String> purchaserList = new ArrayList<String>() {
{
add("Bob");
add("Steve");
}
};
Disjunction prod = Restrictions.disjunction();
prod.add(Restrictions.in("productName", productList));
Disjunction purch = Restrictions.disjunction();
purch.add(Restrictions.in("purchaserName", purchaserList));
criteria.add(Restrictions.and(prod, purch));
List resultList = criteria.list();
结果就是SQL（<property name="show_sql">true</property>）
select this_.PURCHASER_NAME as y0_, this_.PRODUCT_NAME as y1_, this_.PURCHASE_ID as y2_, this_.PRODUCT_NAME as y3_, max(this_.PURCHASE_DATE) as y4_, this_.PURCHASER_NAME as y5_ from purchase this_ where ((this_.PRODUCT_NAME in (?, ?)) and (this_.PURCHASER_NAME in (?, ?))) group by this_.PURCHASER_NAME, this_.PRODUCT_NAME
答案 6 :(得分：0)
在我看来，诀窍是要看到“给我最新消息”等同于“给没有新购买的行”。这就是这种查询：
-- This is SQL
-- Note that if two purchases have exactly the same date, this query will
-- return both; you can fine tune the condition inside the exists clause
-- to avoid this
select *
from purchases p1
where
p1.product_name in ('Notebook', 'Pencil') and
p1.purchaser_name in ('Bob', 'Steve') and
not exists (
select p2.purchase_id
from purchases p2
where
p2.product_name = p1.product_name and
p2.purchaser_name = p1.purchaser_name and
p2.purchase_date > p1.purchase_date
)
order by purchase_id;
尽管这是SQL，但转换为HQL应该非常简单，这对您来说足够了。自从我使用Hibernate Criteria以来已经很久了（如今您倾向于使用JPA API），但这应该类似于以下内容：
DetachedCriteria criteria = DetachedCriteria.forClass(Purchase.class, "p1");
// add here your filters to criteria
// criteria.add(purcharserName in (....));
// criteria.add(productName in (....));
// this appends the not exists clause
DetachedCriteria notExistsCriteria = DetachedCriteria.forClass(Purchase.class, "p2");
notExistsCriteria.add(Restrictions.eqProperty("p2.productName", "p1.productName"));
notExistsCriteria.add(Restrictions.eqProperty("p2.purchaserName", "p1.purchaserName"));
notExistsCriteria.add(Restrictions.gtProperty("p2.purchaseDate", "p1.purchaseDate"));
criteria.add(Subqueries.notExists(notExistsCriteria.setProjection(Projections.property("p1.id"))));
List<Purchase> results = // issue Criteria query
更新：
我看到Hibernate Criteria支持SQL ALL运算符，因此，如果您的数据库支持，您也可以这样写：
DetachedCriteria criteria = DetachedCriteria.forClass(Purchase.class, "p1");
// add here your filters to criteria
// criteria.add(purcharserName in (....));
// criteria.add(productName in (....));
// this appends the p1.purchaseDate > all (...) filter
DetachedCriteria allCriteria = DetachedCriteria.forClass(Purchase.class, "p2");
allCriteria.add(Restrictions.eqProperty("p2.productName", "p1.productName"));
allCriteria.add(Restrictions.eqProperty("p2.purchaserName", "p1.purchaserName"));
criteria.add(Subqueries.propertyGeAll("p1.purchaseDate", allCriteria.setProjection(Projections.property("p2.purchaseDate"))));
List<Purchase> results = // issue Criteria query
阅读起来更加清晰
答案 7 :(得分：0)
假设您具有自动递增ID字段，请尝试以下HQL。
FROM Purchase p WHERE p.id IN(SELECT MAX(p1.id) FROM Purchase p1 WHERE p1.productName IN('Notebook','Pencil') AND p1.purchaseName IN('Bob', 'Steve') GROUP BY p1.productName, p1.purchaseName)
答案 8 :(得分：0)
解决方案是首先使用分离的条件按productName，purchaseName来获取productName，purchaseName和max（purchaseDate）组。这将使我们使用这三个属性来标识唯一行。但是，这里有一个问题，如果同一位购买者同一天购买了同一产品超过一次，那么我们将无法使用上述条件识别唯一行，这将导致从数据库中获取多个记录。要解决此问题，您需要对数据库中的purchaseDate字段使用日期时间或时间戳类型。现在，使用“条件查询”中分离条件的这些属性来获取所需的结果。
DetachedCriteria detachedCriteria = DetachedCriteria.forClass(Purchase.class, "inner");
detachedCriteria.add(Restrictions.in("inner.productName", new String[] { "Notebook", "Pencil" }));
detachedCriteria.add(Restrictions.in("inner.purchaserName", new String[] { "Bob", "Steve" }));
detachedCriteria.setProjection(Projections.projectionList().add(Projections.max("inner.purchaseDate"))
.add(Projections.groupProperty("inner.productName"))
.add(Projections.groupProperty("inner.purchaserName")));
Session session = this.getEntityManager().unwrap(Session.class);
Criteria criteria = session.createCriteria(Purchase.class, "b");
ProjectionList projectionList = Projections.projectionList();
projectionList.add(Projections.property("b.purchaseId"));
projectionList.add(Projections.property("b.productName"));
projectionList.add(Projections.property("b.purchaseDate"));
projectionList.add(Projections.property("b.purchaserName"));
criteria.setProjection(projectionList);
criteria.add(Subqueries.propertiesIn(new String[] { "b.purchaseDate", "b.productName", "b.purchaserName" },
detachedCriteria));
criteria.list();
此条件查询将在mysql中的查询下方触发
select this_.purchase_id as y0_, this_.product_name as y1_, this_.purchase_date as y2_, this_.purchaser_name as y3_ from purchase this_ where (this_.purchase_date, this_.product_name, this_.purchaser_name) in (select max(inner_.purchase_date) as y0_, inner_.product_name as y1_, inner_.purchaser_name as y2_ from purchase inner_ where inner_.product_name in (?, ?) and inner_.purchaser_name in (?, ?) group by inner_.product_name, inner_.purchaser_name)
答案 9 :(得分：0)
List<Purchase> findByProductNameInAndPurchaserNameInAndPurchaseDateBefore(List<String> productNames, List<String> purchaserNames, Date before);
我看不到“购买”实体，但是，如果将“产品”映射为实体，则此查询必须相应地更新。
注意 ：我建议您阅读全文搜索或Hibernate搜索，因为如果您有很多这样的查询，听起来就好像您在您的项目中将需要全文搜索支持。