hibernate分组查询

检索单个对象

Query和Criteria都提供了返回单个对象的方法uniqueResult().

先调用setMaxResult(1)方法，把最大检索数目设为1，在调用uniqueResult()方法。

Hx hx = (Hx)session.createQuery("from Hx")

.setMaxResults(1)

.uniqueResult();

Hx hx = (Hx)session.createCriteria(Hx.class)

.addOrder(Order.asc("name"))

.setMaxResults(1)

.uniqueResult();

与对象属性绑定

Hx hx = new Hx();

hx.setAge("33");

List list = session.createQuery("from Hx as c where c.age=:age")

.setProperties(hx)

.list();

SQL内连接

内连接就是传统的连接操作，用join连接关联表，on作为连接条件，where指定其他限定条件的查询

如：

select hx.name,hx.age,hxhome.home from hx join hxhome on hx.id=hxhome.hxid

SQL左外连接

在结果表中包含第一个表中满足的所有纪录，如果是在连接条件上匹配纪录，则第二个表返回相应的值，否则第二个表返回空值。

如：

select hx.name,hx.age,hxhome.home from hx  left join hxhome on hx.id=hxhome.hxid

SQL右外连接

在结果表中包含第二个表中满足的所有纪录，如果是在连接条件上匹配纪录，则第一个表返回相应的值，否则第一个表返回空值。

如：

select hx.name,hx.age,hxhome.home from hx  right outer join hxhome on hx.id=hxhome.hxid

Hibernate中各种连接

迫切左外连接

以下两种检索方式是等价的，它们都能同时迫切左外连接类B和类C：

//HQL迫切左外连接检索方式

from A a left join fetch a.b b left join fetch a.c c where b is not

null and c is not null

//QBC迫切左外连接检索方式

List result=session.createCriteria(A.class)

.setFetchMode("this.b",FetchMode.EAGER)

.setFetchMode("this.c",FetchMode.EAGER)

.add(Expression.isNotNull("this.b"))

.add(Expression.isNotNull("this.c"))

.list();

迫切左外连接

HQL:

Session session = HibernateSessionFactory.getSession();

List list = session.createQuery("from Hxhome c left join fetch c.hx h") .list();

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

{

Hxhome hh = (Hxhome)list.get(i);

System.out.println("homeid="+hh.getHxid());

System.out.println("home="+hh.getHome());

System.out.println("hxname="+hh.getHx().getName());

}

迫切左外连接

QBC:

List list = session.createCriteria(Hxhome.class)

            .setFetchMode("hx", FetchMode.EAGER)

            .add(Expression.like("home","h%"))

            .list();

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

{

Hxhome hh = (Hxhome)list.get(i);

System.out.println("homeid="+hh.getHxid());

System.out.println("home="+hh.getHome());

System.out.println("hxname="+hh.getHx().getName());

}

QBC中的FetchMode

FetchMode.DEFAULT：表示采用映射文件中配置的检索策略

FetchMode.EAGER：覆盖映射文件中配置的检索策略，在程序中显示指定迫切左外连接检索策略

FetchMode.LAZY：覆盖映射文件中配置的检索策略，在程序中显示指定延迟检索策略

左外连接

HQL：

List list = session.createQuery("from Hxhome c left join  c.hx ")

.list();

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

{

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

Hx hx = (Hx)zmx[1];

Hxhome hh = (Hxhome)zmx[0];

System.out.println("hx="+hx.getName()+"---------hh="+hh.getHome());

}

左外连接

QBC不支持左外连接

内连接

HQL：

List list = session.createQuery("from Hxhome c  join  c.hx ")

.list();

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

{

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

Hx hx = (Hx)zmx[1];

Hxhome hh = (Hxhome)zmx[0];

System.out.println("hx="+hx.getName()+"---------hh="+hh.getHome());

}

QBC：

List list =session.createCriteria(Hxhome.class)

           .createAlias("hx", "h")

           .add(Expression.like("home","h%"))

           .list();          

for(Iterator it=list.iterator();it.hasNext();)

{

Map map = (Map)it.next();

Hxhome hh = (Hxhome)map.get("this");

Hx hx = (Hx)map.get("h");

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

}

右外连接

HQL：

List list = session.createQuery("from Hxhome c right join c.hx h")

.list();          

for(Iterator it=list.iterator();it.hasNext();)

{

Object[] zmx = (Object[])it.next();

Hxhome hh = (Hxhome)zmx[0];

Hx hx = (Hx)zmx[1];

System.out.print(hh.getHome());

System.out.println(hx.getName());

}

右外连接

QBC：

不支持右外连接

HQL支持各种的连接查询

1、默认情况

from Hx c where c.name like ‘h%’

2、迫切左外连接

from Hx c left join fetch c.hxhome where c.name like ‘h%’

3、左连接

from Hx c left join c.hxhome where c.name like ‘h%’

4、迫切内连接

from Hx c join fetch c.hxhome where c.name like ‘h%’

5、内连接

from Hx c join c.hxhome where c.name like ‘h%

6、右外连接

from Hx c right join c.hxhome where c.name like ‘h%

报表查询

1、投影查询

2、使用聚集函数

3、分组查询

投影查询

投影查询：指查询结果仅包含部分实体或实体的部分属性，通过select关键字来实现。

select关键字用于选择对象的部分属性，例如：

Session session = HibernateSessionFactory.getSession();

Transaction tx = session.beginTransaction();

Iterator it = session.createQuery("select c.name,c.age,h.home from Hx c join c.homes h where c.id>0 ")

              .list()

              .iterator();

while(it.hasNext())

{

Object[] row = (Object[])it.next();

String age = (String)row[1];

String home = (String)row[2];

System.out.println("|age="+age+"|home="+home);

}

tx.commit();

session.close();

投影查询

过滤结果中的重复数据—使用set

Iterator it = session.createQuery("select c.name from Hx c")

              .iterate();

Set set = new HashSet();

while(it.hasNext())

{

String it1 = set.iterator();

while(it1.hasNext())

{

String name1 = (String)it1.next();

System.out.println("name1="+name1);

}

投影查询

也可以使用distinct关键字来过滤重复记录

Session session = HibernateSessionFactory.getSession();

Transaction tx = session.beginTransaction();

Iterator it = session.createQuery("select distinct c.name from Hx c")

.iterate();

while(it.hasNext())

{

String 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%';

以上查询语句的查询结果如下：

+----+------+--------------+

| ID | NAME | ORDER_NUMBER |

+----+------+--------------+

|  1 | Tom  | Tom_Order001 |

|  1 | Tom  | Tom_Order002 |

|  1 | Tom  | Tom_Order003 |

+----+------+--------------+

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

投影查询

使用聚集函数

在HQL中可以调用

Count：统计函数

Min：求最小值函数

Max：求最大值函数

Sum：求和函数

Avg：求平均数函数

 Count：统计函数

Session session = HibernateSessionFactory.getSession();

Transaction tx = session.beginTransaction();

Integer count = (Integer)session.createQuery("select count(*) from Hx")

.uniqueResult();

System.out.print(count);

tx.commit();

session.close();

Avg：求平均数函数

Session session = HibernateSessionFactory.getSession();

Transaction tx = session.beginTransaction();

Float count = (Float)session.createQuery("select avg(c.id) from Hx c")

 .uniqueResult();

System.out.print(count);

tx.commit();

session.close();

Sum：求和函数

Session session = HibernateSessionFactory.getSession();

Transaction tx = session.beginTransaction();

Integer count = (Integer)session.createQuery("select sum(c.id) from Hx c")

 .uniqueResult();

System.out.print(count);

tx.commit();

session.close();

Min：求最小值函数 Max：求最大值函数

Session session = HibernateSessionFactory.getSession();

Transaction tx = session.beginTransaction();

Object[] count = (Object[])session.createQuery("select min(c.age),max(c.age) from Hx c")

.uniqueResult();

String min = (String)count[0];

String max = (String)count[1];

System.out.print("min="+min+"|max="+max);

tx.commit();

session.close();

分组查询

Session session = HibernateSessionFactory.getSession();

Transaction tx = session.beginTransaction();

Iterator it = session.createQuery("select c.name,count(c) from Hx c group by c.name")

.iterate();

while(it.hasNext())

{

Object[] oc = (Object[])it.next();

String count = (Integer)oc[1];

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

}

tx.commit();

session.close();

private static final String LIST_COUNT = "select f.type as t,count(f.type) as c from Fetch as f group by type";

public void testCount(){  

  

   Query query = createQuery(LIST_COUNT);

  

   List list = query.list();  

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

   

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

   

    System.out.println(ob[0].toString());

    System.out.println(ob[1].toString());

   }

}

另外：

在hibernate中，用hql语句查询实体类，采用list方法的返回结果为一个List，该List中封装的对象分为以下三种情况：

1.查询全部字段的情况下，如"from 实体类"，list中封装的对象为实体类本身，各属性都将得到填充。

2.只查询一个字段，默认情况下，list中封装的是Object对象。

3.查询两个或两个以上的字段，默认情况下，list中封装的是Object[],长度与所查询的字段数一致。

对于后两种情况，用标签遍历时不太方便，因为无法直接转换成实体类的对象。比较简单的解决方法是：

在hql中使用 select new 包名.类名(属性1，属性2……) from 实体类，同时在实体类中添加带参的构造方法，参数的个数和顺序与（属性1，属性2……) 保持一致，这样我们得到的list中存放的依然是实体类的对象，所查询到的属性得到了填充，使用起来更为方便。