Hibernate的检索方式（2）hql

（9）迫切左外连接：

使用的sql语句仍然是左外连接，它将返回一个对象，要想获取和它关联对象，需要遍历循环。

缺点：循环太多，返回的结果集过于复杂

/**知识点10:    迫切左外连接，返回值是一个对象，要想查询和对象关联的其他对象，需要遍历循环之后获取*/

Query query =session.createQuery("from Customer c left outer join fetch c.orders");

List<Customer> list = query.list();

if(list!=null && list.size()>0){

for(Customer c:list){

System.out.println(c.getId()+"   "+c.getName()+"   "+c.getAge());

Set<Order> orders = c.getOrders();

if(orders!=null && orders.size()>0){

for(Order o:orders){

System.out.println(o.getId()+"   "+o.getOrderNumber()+"   "+o.getPrice());

}

}

}

}

 

（10）左外连接：

/**知识点11：左外连接*/

/**如果查询一个对象，则返回Object对象

 * 如果查询的是多个对象，则返回Object数组对象*/

Query query =session.createQuery("from Customer c left outer join c.orders o");//hql语句等价于：select c,o from Customer c left outer join c.orders o

List<Object[]> list = query.list();

if(list!=null && list.size()>0){

for(Object[] object:list){

Customer c = (Customer)object[0];

Order o = (Order)object[1];

System.out.println(c.getId()+"   "+c.getName()+"   "+c.getAge());

System.out.println(o.getId()+"   "+o.getOrderNumber()+"   "+o.getPrice());

System.out.println("---------------------");

}

}

 

（11）内连接

/**知识点12:    内连接*/

Query query =session.createQuery("from Customer c inner join c.orders o where c.name like 'T%'");//

List<Object[]> list = query.list();

if(list!=null && list.size()>0){

for(Object[] object:list){

Customer c = (Customer)object[0];

Order o = (Order)object[1];

System.out.println(c.getId()+"   "+c.getName()+"   "+c.getAge());

System.out.println(o.getId()+"   "+o.getOrderNumber()+"   "+o.getPrice());

System.out.println("---------------------");

}

}

 

（12）迫切内连接（了解）

//Inner  join  fetch表示迫切内连接检索策略 ,也就是覆盖映射文件中指定的检索策略

Query query = session.createQuery("from Customer c inner join fetch

                                          c.orders o where c.name like 'T%'");

List list = query.list();

 

（13）隐式内连接（了解）

/**

知识点14:    隐式内连接(x) （了解知识）

HQL:

createQuery(“from Order o where o.customer.name like ‘T%’”);

等价于:

from Order o join o.customer c where c.name like ‘T%’

*/

//Query query = session.createQuery("from Order o where o.customer.name like 'T%'");//返回值只有个Order对象

Query query = session.createQuery("from Order o join o.customer c where c.name like 'T%'");//返回值是一个Object对象，其中一个值是Customer，其中一个值Order

query.list();

 

 

（14）右连接（了解）

HQL: right outer join  右外连接   返回是对象数组

 

Query query = session.createQuery("from Customer c

           right outer join c.orders o where c.name like ‘t%'");

List list = query.list();

 

（15）使用SQL风格的交叉连接和隐式内连接（了解）

HQL:

交叉连接查询：from Customer,Order

标准SQL风格的内连接：from Customer c inner join c.orders

SQL风格的隐式内连接查询：:from Customer c,Order o where c.id = o.customer.id

---------------------------------------------------------------------------------

Query query = session.createQuery(“from Customer c,Order o where c.name like ?”);

query.setString(0,”tom”);

List list = query.list();

 

（16）投影查询

l 投影查询: 查询结果仅包含实体的部分属性. 通过 SELECT 关键字实现.

l Query 的 list() 方法返回的集合中包含的是数组类型的元素, 每个对象数组代表查询结果的一条记录

l 可以在持久化类中定义一个对象的构造器来包装投影查询返回的记录, 使程序代码能完全运用面向对象的语义来访问查询结果集.

l 可以通过 DISTINCT 关键字来保证查询结果不会返回重复元素

 

/**知识点17:投影查询(实例)*/

/**如果投影查询，查询一个值，此时返回Object对象

 * 如果投影查询，查询多个值，此时返回Object数组*/

Query query = s.createQuery("select c,o.price from Customer c left outer join c.orders o where c.name='Tom'");

List<Object[]> list = query.list();

if(list!=null && list.size()>0){

for(Object[] object:list){

Customer c = (Customer)object[0];

System.out.println(c.getId()+"   "+c.getName()+"    "+object[1]);

}

}

 

 

//知识点17:投影查询(list集合中存放的对象数组,数组中存放的查询的部分属性)

Query query = s.createQuery("select c.name,o.orderNumber,o.price from Customer c left outer join c.orders o where c.name='Tom'");

List<Object[]> list = query.list();

if(list!=null && list.size()>0){

for(Object[] object:list){

System.out.println(object[0]+"   "+object[1]+"    "+object[2]);

}

}

 

 

实例1：

select c,o.price from Customer c join c.orders o where c.name like ‘T%’

如果希望查询结果中只包含Customer对象，可使用以下形式：

select c from Customer c join c.orders o where c.name like T%’

---------------------------------------------------------------------------------

实例2:

select关键字还能用于选择对象的部分属性

session.createQuery(“select c.id,c.name,o.orderNumber from Customer c

join c.orders o where c.name like ‘T%’”)

对应的sql语句为：

select c.ID,c.NAME,o.ORDER_NUMBER from CUSTOMERS c inner join

ORDERS o on c.ID-=o.CUSTOMER_ID where o.ORDER_NUMBER like’T%’

------------------------------------------------------------------------------------

实例3:

过滤重复元素

createQuery(“select distinct c.name from Customer c”);

总结：投影查询的返回的是Object数组或者是一个Object对象

 

 

（17）构造函数查询

//第一步：创建一个javabean对象，用来封装构造器函数

public class CustomerRow {

private String name;

private String orderNumber;

private Double price;

//构造器

public CustomerRow(){

}

public CustomerRow(String name,String orderNumber,Double price){

this.name = name;

this.orderNumber = orderNumber;

this.price = price;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public String getOrderNumber() {

return orderNumber;

}

public void setOrderNumber(String orderNumber) {

this.orderNumber = orderNumber;

}

public Double getPrice() {

return price;

}

public void setPrice(Double price) {

this.price = price;

}

}

 

//第二步：构造器函数

Query query = s.createQuery("select new cn.itcast.n_queryMethod.CustomerRow(c.name,o.orderNumber,o.price) from Customer c left outer join c.orders o where c.name='Tom'");

List<CustomerRow> list = query.list();

if(list!=null && list.size()>0){

for(CustomerRow cr:list){

System.out.println(cr.getName()+"   "+cr.getOrderNumber()+"   "+cr.getPrice());

}

}

 

 

（19）聚合函数

l 报表查询用于对数据分组和统计, 与 SQL 一样, HQL 利用 GROUP BY 关键字对数据分组, 用 HAVING 关键字对分组数据设定约束条件.

l 在 HQL 查询语句中可以调用以下聚集函数

• count()

• min()

• max()

• sum()

• avg()

 

//使用聚集函数

Query query = s.createQuery("select o.name,count(*) from Customer o group by o.name");

List<Object[]> list = query.list();

System.out.println(list.size());

for(int i=0;i<list.size();i++){

Object [] o = list.get(i);

    System.out.print(o[0]+”            “+o[1]);

    System.out.println();

}

 

使用聚集函数

方式一： count，使用uniqueResult()时，要使用Long进行强转。

Query query = session.createQuery("select count(*) from Customer c");

Long count=(Long)query.uniqueResult();

System.out.println("count "+count);

 /***********************************************************/

方式二：avg

Query query = session.createQuery("select avg(c.age) from Customer c");

Float avg=(Float)query.uniqueResult();

System.out.println("avg "+avg);

/***********************************************************/

方式三：max，min

Query query = session.createQuery("select max(c.age),min(c.age) from  Customer c");

Object[] maxmin=(Object[])query.uniqueResult();

System.out.println("max "+(Long)maxmin[0]);

System.out.println("min "+(Long)maxmin[1]);

 /***********************************************************/

方式四：sum

Query query = session.createQuery("select sum(c.age) from Customer c");

Long sum=(Long)query.uniqueResult();

System.out.println("sum "+sum);