JPA系列十二：JPQL-Select语句

水深无声 2022-02-09 11:19 473阅读 0赞

select语句用于执行查询。  
1、from 子句  
 from 子句是查询语句的必选子句。Select 用来指定查询返回的结果实体或实体的某些属性。From 子句声明查询源实体类，并指定标识符变量（相当于SQL表的别名）。  
 如果不希望返回重复实体，可使用关键字 distinct 修饰。select、from 都是 JPQL 的关键字，通常全大写或全小写，建议不要大小写混用。  
2、查询所有实体  
 查询所有实体的 JPQL 查询字串很简单，例如：`select o from Order o 或 select o from Order as o`  
 关键字 as 可以省去。  
 标识符变量的命名规范与 Java 标识符相同，且区分大小写。  
 调用 EntityManager 的 createQuery() 方法可创建查询对象，接着调用 Query 接口的 getResultList() 方法就可获得查询结果集。例如：

Query query = entityManager.createQuery( "select o from Order o"); 
    List orders = query.getResultList();
    Iterator iterator = orders.iterator();
    while( iterator.hasNext() ) {
    	// 处理Order
    }

3、where子句  
 where子句用于指定查询条件，where跟条件表达式。例如：

select o from Orders o where o.id = 1
    select o from Orders o where o.id > 3 and o.confirm = 'true'	
    select o from Orders o where o.address.streetNumber >= 123

JPQL也支持包含参数的查询，例如：

select o from Orders o where o.id = :myId
    select o from Orders o where o.id = :myId and o.customer = :customerName

注意：参数名前必须冠以冒号，执行查询前须使用Query.setParameter(name, value)方法给参数赋值。  
 也可以不使用参数名而使用参数的序号，例如：  
`select o from Order o where o.id = ?1 and o.customer = ?2`  
 其中 ?1 代表第一个参数，?2 代表第一个参数。在执行查询之前需要使用重载方法Query.setParameter(pos, value) 提供参数值。

Query query = entityManager.createQuery( "select o from 　	Orders o where o.id = ?1 and o.customer = ?2" );
    query.setParameter( 1, 2 );
    query.setParameter( 2, "John" );
    List orders = query.getResultList();
    … …

where条件表达式中可用的运算符基本上与SQL一致，包括：  
 算术运算符：+　-　\*　/　+(正)　-(负)  
 关系运算符：==　<>　>　>=　<　<=　between…and　like　in　is null 等  
 逻辑运算符： and　or 　not  
下面是一些常见查询表达式示例：

// 以下语句查询 Id 介于 100 至 200 之间的订单。
    select o from Orders o where o.id between 100 and 200
    // 以下语句查询国籍为的 'US'、'CN'或'JP' 的客户。
    select c from Customers c where c.county in ('US','CN','JP')
    // 以下语句查询手机号以139开头的客户。%表示任意多个字符序列，包括0个。
    select c from Customers c where c.phone like '139%'
    // 以下语句查询名字包含4个字符，且234位为ose的客户。_表示任意单个字符。
    select c from Customers c where c.lname like '_ose' 
    // 以下语句查询电话号码未知的客户。Nul l用于测试单值是否为空。
    select c from Customers c where c.phone is null
    // 以下语句查询尚未输入订单项的订单。empty用于测试集合是否为空。
    select o from Orders o where o.orderItems is empty

4、查询部分属性  
 如果只须查询实体的部分属性而不需要返回整个实体。例如：  
`select o.id, o.customerName, o.address.streetNumber from Order o order by o.id`  
 执行该查询返回的不再是Orders实体集合，而是一个对象数组的集合(Object\[\])，集合的每个成员为一个对象数组，可通过数组元素访问各个属性。  
5、order by子句  
 order by子句用于对查询结果集进行排序。和SQL的用法类似，可以用 “asc“ 和 "desc“ 指定升降序。如果不显式注明，默认为升序。

select o from Orders o order by o.id
    select o from Orders o order by o.address.streetNumber desc
    select o from Orders o order by o.customer asc, o.id desc

@Test
    public void testOrderBy(){
    	String jpql = "FROM Customer c WHERE c.age > ? ORDER BY c.age DESC";
    	Query query = entityManager.createQuery(jpql).setHint(QueryHints.HINT_CACHEABLE, true);
    	//占位符的索引是从 1 开始
    	query.setParameter(1, 1);
    	List<Customer> customers = query.getResultList();
    	System.out.println(customers.size());
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpemhpcWlhbmcxMjE3_size_16_color_FFFFFF_t_70]

6、group by子句与聚合查询  
 group by 子句用于对查询结果分组统计，通常需要使用聚合函数。常用的聚合函数主要有 AVG、SUM、COUNT、MAX、MIN 等，它们的含义与SQL相同。例如：  
`select max(o.id) from Orders o`  
 没有 group by 子句的查询是基于整个实体类的，使用聚合函数将返回单个结果值，可以使用Query.getSingleResult()得到查询结果。例如：

Query query = entityManager.createQuery(
    					"select max(o.id) from Orders o");
    Object result = query.getSingleResult();
    Long max = (Long)result;

7、Having 子句  
 Having 子句用于对 group by 分组设置约束条件，用法与where 子句基本相同，不同是 where 子句作用于基表或视图，以便从中选择满足条件的记录；having 子句则作用于分组，用于选择满足条件的组，其条件表达式中通常会使用聚合函数。  
 例如，以下语句用于查询订购总数大于100的商家所售商品及数量：

select o.seller, o.goodId, sum(o.amount) from V_Orders o group by 
    o.seller, o.goodId having sum(o.amount) > 100

//查询 order 数量大于 2 的那些 Customer
    @Test
    public void testGroupBy(){
    	String jpql = "SELECT o.customer FROM Order o "
    			+ "GROUP BY o.customer "
    			+ "HAVING count(o.id) >= 2";
    	List<Customer> customers = entityManager.createQuery(jpql).getResultList();
    	System.out.println(customers);
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpemhpcWlhbmcxMjE3_size_16_color_FFFFFF_t_70 1]  
 having子句与where子句一样都可以使用参数。  
8、关联查询  
 在JPQL中，很多时候都是通过在实体类中配置实体关联的类属性来实现隐含的关联(join)查询。例如：`select o from Orders o where o.address.streetNumber=2000`  
 上述JPQL语句编译成以下SQL时就会自动包含关联，默认为左关联。  
 在某些情况下可能仍然需要对关联做精确的控制。为此，JPQL 也支持和 SQL 中类似的关联语法。如：  
  left out join / left join  
  inner join  
  left join / inner join fetch  
  其中，left join和left out join等义，都是允许符合条件的右边表达式中的实体为空。  
 例如，以下外关联查询可以找出所有客户实体记录，即使它未曾订货：  
`select c from Customers c left join c.orders o`  
 以下内关联查询只找出所有曾订过商品的客户实体记录：  
`select c from Customers c inner join c.orders o`  
 如果001号客户下过5次订单的话，以下fetch关联查询将得到 5个客户实体的引用，并且执行了 5 个订单的查询：  
`select c from Customers c left join fetch c.orders o where c.id=001`

// JPQL 的关联查询同 HQL 的关联查询.
    @Test
    public void testLeftOuterJoinFetch(){
    	String jpql = "FROM Customer c LEFT OUTER JOIN FETCH c.orders WHERE c.id = ?";
    	Customer customer = 
    			(Customer) entityManager.createQuery(jpql).setParameter(1, 6).getSingleResult();
    	System.out.println(customer.getLastName());
    	System.out.println(customer.getOrders().size());
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpemhpcWlhbmcxMjE3_size_16_color_FFFFFF_t_70 2]  
9、子查询  
 JPQL也支持子查询，在 where 或 having 子句中可以包含另一个查询。当子查询返回多于 1 个结果集时，它常出现在 any、all、exist s表达式中用于集合匹配查询。它们的用法与SQL语句基本相同。

@Test
    public void testSubQuery(){
    	//查询所有 Customer 的 lastName 为 YY 的 Order
    	String jpql = "SELECT o FROM Order o "
    			+ "WHERE o.customer = (SELECT c FROM Customer c WHERE c.lastName = ?)";
    	Query query = entityManager.createQuery(jpql).setParameter(1, "YY");
    	List<Order> orders = query.getResultList();
    	System.out.println(orders.size());
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpemhpcWlhbmcxMjE3_size_16_color_FFFFFF_t_70 3]  
10、使用 Hibernate 的查询缓存

//使用 hibernate 的查询缓存. 
    @Test
    public void testQueryCache(){
    	String jpql = "FROM Customer c WHERE c.age > ?";
    	Query query = entityManager.createQuery(jpql).setHint(QueryHints.HINT_CACHEABLE, true);
    	//占位符的索引是从 1 开始
    	query.setParameter(1, 1);
    	List<Customer> customers = query.getResultList();
    	System.out.println(customers.size());
    	query = entityManager.createQuery(jpql).setHint(QueryHints.HINT_CACHEABLE, true);
    	//占位符的索引是从 1 开始
    	query.setParameter(1, 1);
    	customers = query.getResultList();
    	System.out.println(customers.size());
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpemhpcWlhbmcxMjE3_size_16_color_FFFFFF_t_70 4]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpemhpcWlhbmcxMjE3_size_16_color_FFFFFF_t_70]: /images/20220206/160706ddc8a943eba7987e0a7a63598f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpemhpcWlhbmcxMjE3_size_16_color_FFFFFF_t_70 1]: /images/20220206/edc12791b7274ceb85014eff60ee626d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpemhpcWlhbmcxMjE3_size_16_color_FFFFFF_t_70 2]: /images/20220206/43e958bb7a154b86839dd826c20a0e94.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpemhpcWlhbmcxMjE3_size_16_color_FFFFFF_t_70 3]: /images/20220206/4a3602105f764ce3afdd457189cab24a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpemhpcWlhbmcxMjE3_size_16_color_FFFFFF_t_70 4]: /images/20220206/e4f479ef09394881839d0009357f5fc2.png