Hibernate查询语句

1 hql查询

Hibernate的查询语句，hiberante提供的面向对象的查询语言，和sql语句的语法的相似.而且严格区分大小写。

1.1 from字句

 /**
  * hql: from 字句
  * ***/
 @Test
 public void  testFromHql()
 {
     //获得Session对象
     Session session=sf.openSession();
     String hql="from Dept";
     //获得部门对象的集合
     List<Dept>   dlist = session.createQuery(hql).list();
     for(Dept d:dlist){
         System.out.println(d.getDname());
     }
     //释放资源
     session.close();
 }

语法：from  类名

1 from  类名

返回值就是该类对应的对象的集合

2 关联查询

From   类名1,…类名N  返回值为Object类的数组的集合

Object类型数组中元素为：类名1  ….类名N对应的对象

1.2 select字句

select:后指定一个属性

Select:后指定两个属性

 /**
  * hql: select 字句
  * select查询获得不是某个pojo类的对象集合
  * ***/
 @Test
 public void  testSelectHql()
 {
     //获得Session对象
     Session session=sf.openSession();
     //select：后面指定一个属性
     /*String hql="select dname from Dept";
         //获得指定属性类型对应的集合
         List<String>  dlist = session.createQuery(hql).list();
         for(String d:dlist){
             System.out.println(d);
         }*/
     //select:后面指定多个属性
     String hql="select did,dname from Dept";
     //获得Object类型数组的集合
     List<Object[]>  dlist = session.createQuery(hql).list();
     for(Object[] d:dlist)
     {
         System.out.println(d[0]+"\t"+d[1]);
     }
     //释放资源
     session.close();
 }

Select返回值三种情况

1 select 指定一个属性

返回值为属性对应的类型的集合

2 select指定n个属性

返回值为Object[]数组的集合，数组中元素为指定属性对应的值

3 select获得结果为单行单列

直接返回Object类型的对象，uniqueResult()

1.3关联查询

 /***
  * 关联查询
  * ***/
 @Test
 public void  testJoinHql()
 {
     //获得Session对象
     Session session=sf.openSession();
     /*String hql="from Dept d,Post p where d.did=p.dept.did";
         //获得Object类型的数组集合，数组中元素是关联的pojo类对象
         List<Object[]>  dlist = session.createQuery(hql).list();
         for(Object[] d:dlist){
             //System.out.println(d[0]+"\t"+d[1]);
             Dept dept=(Dept)d[0];
             Post post=(Post)d[1];
             System.out.println(dept.getDname()+"\t"+post.getPname());
         }*/
     String hql="select d.dname,p.pname from Dept d,Post p where d.did=p.dept.did";
     //获得Object类型的数组集合，数组中元素是select后面指定的属性
     List<Object[]>  dlist = session.createQuery(hql).list();
     for(Object[] d:dlist)
     {
         System.out.println(d[0]+"\t"+d[1]);
     }
     //释放资源
     session.close();
 }

1.4连接查询

 /***
  * 内连接：inner join
  * ***/
 @Test
 public void  testInnerJoinHql()
 {
     //获得Session对象
     Session session=sf.openSession();
     String hql="from Dept d inner join d.posts ";
     List<Object[]> list = session.createQuery(hql).list();
     //遍历结果集
     for(Object[] arr:list)
     {
         System.out.println(arr[0]+"\t"+arr[1]);
     }
     //释放资源
     session.close();
 }
 /***
  * 做外连接：left join
  * ***/
 @Test
 public void  testLeftJoinHql()
 {
     //获得Session对象
     Session session=sf.openSession();
     String hql="from Dept d left join d.posts p  ";
     List<Object[]> list = session.createQuery(hql).list();
     //遍历结果集
     for(Object[] arr:list)
     {
         System.out.println(arr[0]+"\t"+arr[1]);
     }
     //释放资源
     session.close();
 }

不需要指定关联的条件，
hibernate根据映射文件自动关联

1.5聚合和分组查询

 /***
  * 聚合和分组查询
  * max
  * min
  * avg
  * sum
  * ***/
 @Test
 public void  testFunGroup()
 {
     //获得Session对象
     Session session=sf.openSession();
     /***获得每个部门下的岗位人数***/
     String hql="select p.dept.dname ,count(pid) from  Post p group by p.dept.did  ";
     List<Object[]> list = session.createQuery(hql).list();
     //遍历结果集
     for(Object[] arr:list)
     {
         System.out.println(arr[0]+"\t"+arr[1]);
     }
     //释放资源
     session.close();
 }

1.6 where 字句

和属性的表达式写法一样

And    or    not

<   >=   <=

In , not in

Like,not like

Between    and

1.7 order by字句

2 条件查询

标准的面向对象的查询，

 public class TestMany2One
 {
     /**
      * 通过静态代码块加载配置文件
      * ****/
     static SessionFactory sf=null;
     static
     {
         //1 创建Configuration对象，用来加载hibernate的配置文件
         Configuration  cfg = new Configuration();
         //2加载配置文件
         cfg.configure("hibernate.cfg.xml");
         //3通过cfg构造一个会话工厂对象
         sf=cfg.buildSessionFactory();
     }
     /**
      * criteria：查询所有（所有列，所有行）
      * ***/
     @Test
     public void  testCriteria()
     {
         //获得Session对象
         Session session=sf.openSession();
         List<Dept> list=session.createCriteria(Dept.class, "d").list();
         for(Dept d:list){
             System.out.println(d.getDname());
         }
         //释放资源
         session.close();
     }
     /**
      * criteria：查询所有（所有列，所有行）
      * 进行结果的过滤
      * ***/
     @Test
     public void  testCriteria2()
     {
         //获得Session对象
         Session session=sf.openSession();
         Criteria c = session.createCriteria(Dept.class, "d");
         //加where过滤条件
         //c.add(Restrictions.eq("d.did", 11));
         //c.add(Restrictions.like("d.dname", "安慰%"));
         //c.add(Restrictions.)
         List<Dept> list = c.list();
         for(Dept d:list)
         {
             System.out.println(d.getDname());
         }
         //释放资源
         session.close();
     }
     /**
      * criteria：查询所有（所有列，所有行）
      * 进行结果的过滤
      * 查询指定的列：进行投影查询Projections
      * ***/
     @Test
     public void  testCriteria3()
     {
         //获得Session对象
         Session session=sf.openSession();
         Criteria c = session.createCriteria(Dept.class, "d");
         //查询指定的列
         c.setProjection(Projections.projectionList().add(Projections.property("dname"))
                 .add(Projections.property("did")));
         List<Object[]> list = c.list();
         for(Object[] d:list)
         {
             System.out.println(d[0]+"\t"+d[1]);
         }
         //释放资源
         session.close();
     }
     /**
      * criteria：查询所有（所有列，所有行）
      * 进行结果的过滤
      * 查询指定的列：进行投影查询Projections
      * 投影，聚合 ，分组
      *
      * ***/
     @Test
     public void  testCriteria4()
     {
         //获得Session对象
         Session session=sf.openSession();
         Criteria c = session.createCriteria(Dept.class, "d");
         //查询指定的列
         c.setProjection(Projections.projectionList().add(Projections.property("d.dname"))
                 .add(Projections.property("d.did"))
                 .add(Projections.count("d.did"))
                 .add(Projections.groupProperty("d.dname")));
         List<Object[]> list = c.list();
         for(Object[] d:list)
         {
             System.out.println(d[0]+"\t"+d[1]+"\t"+d[2]);
         }
         //释放资源
         session.close();
     }
     /***
      * 关联查询
      *
      * ****/
     @Test
     public void  testCriteria5()
     {
         //获得Session对象
         Session session=sf.openSession();
         Criteria c = session.createCriteria(Dept.class, "d");
         //关联岗位
         c.createAlias("d.posts", "p");
         //查询指定的列
         //c.add(Restrictions.eqProperty("d.did", "p.dept.did"));
         List<Dept> list = c.list();
         for(Dept d:list)
         {
             System.out.print(d.getDname()+"\t");
             Set<Post> posts=d.getPosts();
             for(Post p:posts)
             {
                 System.out.print(p.getPname()+"\t\t");
             }
             System.out.println();
         }
         //释放资源
         session.close();
     }
 }

3 Hql语句的参数封装

 /**
  * Hql:的参数
  * ***/
 @Test
 public void  testHqlParam()
 {
     //获得Session对象
     Session session=sf.openSession();
     //定义hql语句，hql语句中包含占位符
     String hql="from Dept d where d.dname=? ";
     session.createQuery(hql).setString(0, "研发部");
     //常用的
     String hql2="from Dept d where d.dname=:dname";
     List<Dept> list=session.createQuery(hql2).setString("dname", "研发部").list();
     for(Dept d:list)
     {
         System.out.println(d.getDid()+"\t"+d.getDname());
     }
     //释放资源
     session.close();
 }

1 from  类名

返回值就是该类对应的对象的集合

2 关联查询

From   类名1,…类名N

返回值为Object类的数组的集合

Object类型数组中元素为：类名1

….类名N对应的对象

Select返回值三种情况

1 select 指定一个属性

返回值为属性对应的类型的集合

2 select指定n个属性

返回值为Object[]数组的集合，数组中元素为指定属性对应的值

3 select获得结果为单行单列

直接返回Object类型的对象，uniqueResult()

不需要指定关联的条件，
hibernate根据映射文件自动关联