Question

我需要调整以下代码示例。

我有一个MySQL查询，看起来像这样（2015-05-04和2015-05-06是动态的，象征着时间范围）

SELECT * FROM cars c WHERE c.id NOT IN ( SELECT fkCarId FROM bookings WHERE 
    (fromDate <= '2015-05-04' AND toDate >= '2015-05-04') OR
    (fromDate <= '2015-05-06' AND toDate >= '2015-05-06') OR
    (fromDate >= '2015-05-04' AND toDate <= '2015-05-06'))

我有一个bookings表和一个cars表。我想知道哪个车在一个时间范围内可用。 SQL查询就像一个魅力。

我想将此“转换”为CriteriaBuilder输出。我在过去3个小时内阅读了这个输出的文档（显然，这不起作用）。我甚至跳过了子查询中的where部分。

CriteriaBuilder cb = getEntityManager().getCriteriaBuilder();
CriteriaQuery<Cars> query = cb.createQuery(Cars.class);
Root<Cars> poRoot = query.from(Cars.class);
query.select(poRoot);

Subquery<Bookings> subquery = query.subquery(Bookings.class);
Root<Bookings> subRoot = subquery.from(Bookings.class);
subquery.select(subRoot);
Predicate p = cb.equal(subRoot.get(Bookings_.fkCarId),poRoot);
subquery.where(p);

TypedQuery<Cars> typedQuery = getEntityManager().createQuery(query);

List<Cars> result = typedQuery.getResultList();

另一个问题：fkCarId未定义为外键，它只是一个整数。有没有办法以这种方式修复它？

Answer 1

我在MySQL数据库中创建了以下两个表，只包含必要的字段。

mysql> desc cars;
+--------------+---------------------+------+-----+---------+----------------+
| Field        | Type                | Null | Key | Default | Extra          |
+--------------+---------------------+------+-----+---------+----------------+
| car_id       | bigint(20) unsigned | NO   | PRI | NULL    | auto_increment |
| manufacturer | varchar(100)        | YES  |     | NULL    |                |
+--------------+---------------------+------+-----+---------+----------------+
2 rows in set (0.03 sec)

mysql> desc bookings;
+------------+---------------------+------+-----+---------+----------------+
| Field      | Type                | Null | Key | Default | Extra          |
+------------+---------------------+------+-----+---------+----------------+
| booking_id | bigint(20) unsigned | NO   | PRI | NULL    | auto_increment |
| fk_car_id  | bigint(20) unsigned | NO   | MUL | NULL    |                |
| from_date  | date                | YES  |     | NULL    |                |
| to_date    | date                | YES  |     | NULL    |                |
+------------+---------------------+------+-----+---------+----------------+
4 rows in set (0.00 sec)

booking_id表中的

bookings是主键，fk_car_id是引用car_id表的主键（cars）的外键

使用IN()子查询的相应JPA条件查询如下所示。

CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
CriteriaQuery<Cars> criteriaQuery = criteriaBuilder.createQuery(Cars.class);
Metamodel metamodel = entityManager.getMetamodel();
Root<Cars> root = criteriaQuery.from(metamodel.entity(Cars.class));

Subquery<Long> subquery = criteriaQuery.subquery(Long.class);
Root<Bookings> subRoot = subquery.from(metamodel.entity(Bookings.class));
subquery.select(subRoot.get(Bookings_.fkCarId).get(Cars_.carId));

List<Predicate> predicates = new ArrayList<Predicate>();

ParameterExpression<Date> fromDate1 = criteriaBuilder.parameter(Date.class);
Predicate exp1 = criteriaBuilder.lessThanOrEqualTo(subRoot.get(Bookings_.fromDate), fromDate1);
ParameterExpression<Date> toDate1 = criteriaBuilder.parameter(Date.class);
Predicate exp2 = criteriaBuilder.greaterThanOrEqualTo(subRoot.get(Bookings_.toDate), toDate1);
Predicate and1 = criteriaBuilder.and(exp1, exp2);

ParameterExpression<Date> fromDate2 = criteriaBuilder.parameter(Date.class);
Predicate exp3 = criteriaBuilder.lessThanOrEqualTo(subRoot.get(Bookings_.fromDate), fromDate2);
ParameterExpression<Date> toDate2 = criteriaBuilder.parameter(Date.class);
Predicate exp4 = criteriaBuilder.greaterThanOrEqualTo(subRoot.get(Bookings_.toDate), toDate2);
Predicate and2 = criteriaBuilder.and(exp3, exp4);

ParameterExpression<Date> fromDate3 = criteriaBuilder.parameter(Date.class);
Predicate exp5 = criteriaBuilder.greaterThanOrEqualTo(subRoot.get(Bookings_.fromDate), fromDate3);
ParameterExpression<Date> toDate3 = criteriaBuilder.parameter(Date.class);
Predicate exp6 = criteriaBuilder.lessThanOrEqualTo(subRoot.get(Bookings_.toDate), toDate3);
Predicate and3 = criteriaBuilder.and(exp5, exp6);

Predicate or = criteriaBuilder.or(and1, and2, and3);
predicates.add(or);
subquery.where(predicates.toArray(new Predicate[0]));

criteriaQuery.where(criteriaBuilder.in(root.get(Cars_.carId)).value(subquery).not());

List<Cars> list = entityManager.createQuery(criteriaQuery)
        .setParameter(fromDate1, new Date("2015/05/04"))
        .setParameter(toDate1, new Date("2015/05/04"))
        .setParameter(fromDate2, new Date("2015/05/06"))
        .setParameter(toDate2, new Date("2015/05/06"))
        .setParameter(fromDate3, new Date("2015/05/04"))
        .setParameter(toDate3, new Date("2015/05/06"))
        .getResultList();

它会产生您感兴趣的以下SQL查询（在Hibernate 4.3.6 final上进行测试，但在此上下文中，平均ORM框架不应存在任何差异）。

SELECT
    cars0_.car_id AS car_id1_7_,
    cars0_.manufacturer AS manufact2_7_ 
FROM
    project.cars cars0_ 
WHERE
    cars0_.car_id NOT IN  (
        SELECT
            bookings1_.fk_car_id 
        FROM
            project.bookings bookings1_ 
        WHERE
            bookings1_.from_date<=? 
            AND bookings1_.to_date>=? 
            OR bookings1_.from_date<=? 
            AND bookings1_.to_date>=? 
            OR bookings1_.from_date>=? 
            AND bookings1_.to_date<=?
    )

_{上述查询的WHERE子句中的条件表达式周围的括号在技术上完全是多余的，只有Hibernate忽略的更好的可读性才需要--Hibernate不必考虑它们。 /子>}

但我个人更喜欢使用EXISTS运算符。因此，可以如下重建查询。

CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
CriteriaQuery<Cars> criteriaQuery = criteriaBuilder.createQuery(Cars.class);
Metamodel metamodel = entityManager.getMetamodel();
Root<Cars> root = criteriaQuery.from(metamodel.entity(Cars.class));

Subquery<Long> subquery = criteriaQuery.subquery(Long.class);
Root<Bookings> subRoot = subquery.from(metamodel.entity(Bookings.class));
subquery.select(criteriaBuilder.literal(1L));

List<Predicate> predicates = new ArrayList<Predicate>();

ParameterExpression<Date> fromDate1 = criteriaBuilder.parameter(Date.class);
Predicate exp1 = criteriaBuilder.lessThanOrEqualTo(subRoot.get(Bookings_.fromDate), fromDate1);
ParameterExpression<Date> toDate1 = criteriaBuilder.parameter(Date.class);
Predicate exp2 = criteriaBuilder.greaterThanOrEqualTo(subRoot.get(Bookings_.toDate), toDate1);
Predicate and1 = criteriaBuilder.and(exp1, exp2);

ParameterExpression<Date> fromDate2 = criteriaBuilder.parameter(Date.class);
Predicate exp3 = criteriaBuilder.lessThanOrEqualTo(subRoot.get(Bookings_.fromDate), fromDate2);
ParameterExpression<Date> toDate2 = criteriaBuilder.parameter(Date.class);
Predicate exp4 = criteriaBuilder.greaterThanOrEqualTo(subRoot.get(Bookings_.toDate), toDate2);
Predicate and2 = criteriaBuilder.and(exp3, exp4);

ParameterExpression<Date> fromDate3 = criteriaBuilder.parameter(Date.class);
Predicate exp5 = criteriaBuilder.greaterThanOrEqualTo(subRoot.get(Bookings_.fromDate), fromDate3);
ParameterExpression<Date> toDate3 = criteriaBuilder.parameter(Date.class);
Predicate exp6 = criteriaBuilder.lessThanOrEqualTo(subRoot.get(Bookings_.toDate), toDate3);
Predicate and3 = criteriaBuilder.and(exp5, exp6);

Predicate equal = criteriaBuilder.equal(root, subRoot.get(Bookings_.fkCarId));
Predicate or = criteriaBuilder.or(and1, and2, and3);
predicates.add(criteriaBuilder.and(or, equal));
subquery.where(predicates.toArray(new Predicate[0]));

criteriaQuery.where(criteriaBuilder.exists(subquery).not());

List<Cars> list = entityManager.createQuery(criteriaQuery)
        .setParameter(fromDate1, new Date("2015/05/04"))
        .setParameter(toDate1, new Date("2015/05/04"))
        .setParameter(fromDate2, new Date("2015/05/06"))
        .setParameter(toDate2, new Date("2015/05/06"))
        .setParameter(fromDate3, new Date("2015/05/04"))
        .setParameter(toDate3, new Date("2015/05/06"))
        .getResultList();

它生成以下SQL查询。

SELECT
    cars0_.car_id AS car_id1_7_,
    cars0_.manufacturer AS manufact2_7_ 
FROM
    project.cars cars0_ 
WHERE
    NOT (EXISTS (SELECT
        1 
    FROM
        project.bookings bookings1_ 
    WHERE
        (bookings1_.from_date<=? 
        AND bookings1_.to_date>=? 
        OR bookings1_.from_date<=? 
        AND bookings1_.to_date>=? 
        OR bookings1_.from_date>=? 
        AND bookings1_.to_date<=?) 
        AND cars0_.car_id=bookings1_.fk_car_id))

返回相同的结果列表。

其他

这里subquery.select(criteriaBuilder.literal(1L));，在EclipseLink，EclipseLink gets confused上的复杂子查询语句中使用criteriaBuilder.literal(1L)等表达式，并导致异常。因此，在EclipseLink上编写复杂的子查询时可能需要考虑它。在这种情况下只需选择id，例如

subquery.select(subRoot.get(Bookings_.fkCarId).get(Cars_.carId));

与第一种情况一样。注意：如果在EclipseLink上运行如上所述的表达式，您将在SQL查询生成中看到odd behaviour，但结果列表将完全相同。

您也可以使用在后端数据库系统上更高效的连接，在这种情况下，您需要使用DISTINCT来过滤掉可能的重复行，因为您需要父级的结果列表表。如果详细表中存在多个子行，则结果列表可能包含重复行 - bookings表示相应的父行cars。我将它留给你。：）这就是它的用法。

CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder(); CriteriaQuery<Cars> criteriaQuery = criteriaBuilder.createQuery(Cars.class); Metamodel metamodel = entityManager.getMetamodel(); Root<Cars> root = criteriaQuery.from(metamodel.entity(Cars.class)); criteriaQuery.select(root).distinct(true); ListJoin<Cars, Bookings> join = root.join(Cars_.bookingsList, JoinType.LEFT); ParameterExpression<Date> fromDate1 = criteriaBuilder.parameter(Date.class); Predicate exp1 = criteriaBuilder.lessThanOrEqualTo(join.get(Bookings_.fromDate), fromDate1); ParameterExpression<Date> toDate1 = criteriaBuilder.parameter(Date.class); Predicate exp2 = criteriaBuilder.greaterThanOrEqualTo(join.get(Bookings_.toDate), toDate1); Predicate and1 = criteriaBuilder.and(exp1, exp2); ParameterExpression<Date> fromDate2 = criteriaBuilder.parameter(Date.class); Predicate exp3 = criteriaBuilder.lessThanOrEqualTo(join.get(Bookings_.fromDate), fromDate2); ParameterExpression<Date> toDate2 = criteriaBuilder.parameter(Date.class); Predicate exp4 = criteriaBuilder.greaterThanOrEqualTo(join.get(Bookings_.toDate), toDate2); Predicate and2 = criteriaBuilder.and(exp3, exp4); ParameterExpression<Date> fromDate3 = criteriaBuilder.parameter(Date.class); Predicate exp5 = criteriaBuilder.greaterThanOrEqualTo(join.get(Bookings_.fromDate), fromDate3); ParameterExpression<Date> toDate3 = criteriaBuilder.parameter(Date.class); Predicate exp6 = criteriaBuilder.lessThanOrEqualTo(join.get(Bookings_.toDate), toDate3); Predicate and3 = criteriaBuilder.and(exp5, exp6); Predicate or = criteriaBuilder.not(criteriaBuilder.or(and1, and2, and3)); Predicate isNull = criteriaBuilder.or(criteriaBuilder.isNull(join.get(Bookings_.fkCarId))); criteriaQuery.where(criteriaBuilder.or(or, isNull)); List<Cars> list = entityManager.createQuery(criteriaQuery) .setParameter(fromDate1, new Date("2015/05/04")) .setParameter(toDate1, new Date("2015/05/04")) .setParameter(fromDate2, new Date("2015/05/06")) .setParameter(toDate2, new Date("2015/05/06")) .setParameter(fromDate3, new Date("2015/05/04")) .setParameter(toDate3, new Date("2015/05/06")) .getResultList();

它生成以下SQL查询。

SELECT DISTINCT cars0_.car_id AS car_id1_7_, cars0_.manufacturer AS manufact2_7_ FROM project.cars cars0_ LEFT OUTER JOIN project.bookings bookingsli1_ ON cars0_.car_id=bookingsli1_.fk_car_id WHERE ( bookingsli1_.from_date>? OR bookingsli1_.to_date<? ) AND ( bookingsli1_.from_date>? OR bookingsli1_.to_date<? ) AND ( bookingsli1_.from_date<? OR bookingsli1_.to_date>? ) OR bookingsli1_.fk_car_id IS NULL

可以注意到，Hibernate提供程序反转WHERE子句中的条件语句以响应WHERE NOT(...)。其他提供者也可能生成确切的WHERE NOT(...)，但毕竟这与问题中写的相同，并产生与之前情况相同的结果列表。

_{未指定右连接。因此，JPA提供者不必实现它们。他们中的大多数都不支持正确的联接。}

相应的JPQL仅仅是为了完整性：）

IN()查询：

SELECT c FROM cars AS c WHERE c.carid NOT IN (SELECT b.fkcarid.carid FROM bookings AS b WHERE b.fromdate <=? AND b.todate >=? OR b.fromdate <=? AND b.todate >=? OR b.fromdate >=? AND b.todate <=? )

EXISTS()查询：

SELECT c FROM cars AS c WHERE NOT ( EXISTS (SELECT 1 FROM bookings AS b WHERE ( b.fromdate <=? AND b.todate >=? OR b.fromdate <=? AND b.todate >=? OR b.fromdate >=? AND b.todate <=? ) AND c.carid = b.fkcarid) )

最后一个使用左连接（带有命名参数）：

SELECT DISTINCT c FROM Cars AS c LEFT JOIN c.bookingsList AS b WHERE NOT (b.fromDate <=:d1 AND b.toDate >=:d2 OR b.fromDate <=:d3 AND b.toDate >=:d4 OR b.fromDate >=:d5 AND b.toDate <=:d6) OR b.fkCarId IS NULL

所有上述JPQL语句都可以使用您已知的以下方法运行。

List<Cars> list=entityManager.createQuery("Put any of the above statements", Cars.class) .setParameter("d1", new Date("2015/05/04")) .setParameter("d2", new Date("2015/05/04")) .setParameter("d3", new Date("2015/05/06")) .setParameter("d4", new Date("2015/05/06")) .setParameter("d5", new Date("2015/05/04")) .setParameter("d6", new Date("2015/05/06")) .getResultList();

在需要/需要时，用相应的索引/位置参数替换命名参数。

所有这些JPQL语句也生成与上述条件API生成的SQL语句相同的SQL语句。

在这种情况下，尤其是在此情况下，我总是会避免IN()子查询使用MySQL。我会使用IN()子查询，当且仅当它们是绝对需要的情况，例如我们需要确定的时候结果集或删除基于静态值列表的行列表，例如

SELECT * FROM table_name WHERE id IN (1, 2, 3, 4, 5);` DELETE FROM table_name WHERE id IN(1, 2, 3, 4, 5);

等同。

在这种情况下，我总是更喜欢使用EXISTS运算符的查询，因为结果列表涉及根据另一个表中的条件只有一个表。加盟在这种情况下，将产生前面提到的需要过滤掉的重复行使用DISTINCT，如上面的一个查询中所示。

我最好使用连接，当要检索的结果集是从多个数据库表中组合 - 无论如何都必须使用。

毕竟，一切都取决于很多事情。这些都不是里程碑。

_{免责声明：我对RDBMS知之甚少。}

_{注意：我已使用参数化/重载已弃用的日期构造函数 - Date(String s)用于与所有SQL查询关联的索引/位置参数用于纯测试目的的案例只是为了避免你已经知道的java.util.SimpleDateFormat噪音的整个混乱。你也可以使用其他更好的API，比如Joda Time（Hibernate支持它），java.sql.*（那些是java.util.Date的子类），Java 8中的Java Time（现在大多不支持）定制）当需要/需要时。}

希望有所帮助。

Answer 2

如果你这样做格式会运行得更快：

SELECT c.*
    FROM cars c
    LEFT JOIN bookings b 
             ON b.fkCarId = c.id
            AND (b.fromDate ... )
    WHERE b.fkCarId IS NULL;

此表单仍然效率不高，因为它必须扫描所有cars，然后每次到达bookings。

您需要fkCarId上的索引。 “fk”闻起来像FOREIGN KEY，意味着一个索引。请提供SHOW CREATE TABLE进行确认。

如果CriteriaBuilder无法构建，请向他们抱怨或将其排除在外。

在周围翻转它可能运行得更快：

SELECT c.*
    FROM bookings b 
    JOIN cars c
           ON b.fkCarId = c.id
    WHERE NOT (b.fromDate ... );

在这个公式中，我希望在bookings上进行表扫描，过滤掉保留的字符，然后只需到达cars所需的行。如果可用的汽车很少，这可能会更快。

将条件表达式与＆＃34; AND＆＃34;相结合和＆＃34;或＆＃34;谓词使用JPA标准API

2 个答案: