Hibernate查询

Hibernate Query Language

 Query q =session.createQuery("from Categoryc orderby c.name desc");
 List<Category> categories =(List<Category>)q.list();

HQL语言大小写不敏感，但是涉及到Java类名、package名、属性名时，大小写敏感

可以使用冒号(：)，作为占位符，来接受参数使用。如下(链式编程)

Query q=session.createQuery("from Category c wherec.id > :min and c.id <:max")
            .setInteger("min", 2)
            .setInteger("max", 8);

或

Query q=session.createQuery("from Category c wherec.id > :min and c.id <:max")
            .setParameter("min", 2)
            .setParameter("max", 8);
List<Category> categories= (List<Category>)q.list();

 

或者使用问号作为占位符

Query q=session.createQuery("from Category c where c.id = ? and c.name = ? ");
q.setInteger(0,12);
q.setString(1”名称”);

 

分页查询

Query q=session.createQuery("from Category c orderby c.name desc");
        q.setMaxResults(4);//每页显示的最大记录数
        q.setFirstResult(2);//从第几条开始显示，从0开始
        List<Category> categories =(List<Category>)q.list();

 

当返回的实例明确只有一个或者为null的时候可以使用uniqueResult方法查询，当返回的实例大于一个的时候的抛出NonUniqueResultException

String hql="from User u where u.id=?";    
User user = (User)session.createQuery(hql).setString(0,id).uniqueResult();

 

查询部分属性（返回Object []数组）

List arr=newArrayList();
   try {
    String hql="select s.SName,s.SSex fromStu as s";
    Query query=this.GetSession().createQuery(hql);
    List list=query.list();
    Iterator iter=list.iterator();
    while(iter.hasNext()){
     Object[] obj=(Object[]) iter.next();
     Stu s=new Stu();
     s.setSName(obj[0].toString());
     s.setSSex(obj[1].toString());
     arr.add(s);
    }
   } catch (HibernateException e) {
    this.CloseSession();
   }

 

根据主键查询

 Stu stu=(Stu)this.GetSession().get(Stu.class, id);

 

模糊查询

public List getallQueryLike(String name){
   List arr=null;
   try {
    String hql="from Stu as s wheres.SName like :name";
    Query query=this.GetSession().createQuery(hql);
    query.setString("name","%"+name+"%");
    // %必须写在参数里，而不能卸载SQL语句中
    //错误写法：query.setString("name","'%"+name+"%'");
    arr=query.list();
   } catch (HibernateException e) {
    throw e;
   }finally{
    this.CloseSession();
   }
   return arr;
}

 

返回List类型

List<List> list2 =session.createQuery("select newList(c.name,c.mother,c.createDate) from ……").list();
for(List row :list2){
      for(Object obj : row){
             System.out.println(obj);
      }
}

 

返回Map类型

List listMap =session.createQuery("select new Map(c.nameas name,c.mother as mother,c.createDate as createDate) from ……").list();
for(Map map :(List<Map>) listMap){
      System.out.println(map.get(name));
      System.out.println(map.get(mother));
      System.out.println(map.get(createDate));
}

 

返回Java实体对象

List<Cat> catList = session.createQuery("select newCat(cat.name,Cat.createDate) from Cat c").list();

 

跨表查询

List<Event> eventList = session.createQuery("select e from Event e where e.cat.name = 'ketty'").list();

表面上只查询了Event表，实际上因为where子句用到了e.cat.name，将会查询Event表与Cat表

 

HQL中的join只能用在一对一、一对对、多对一、多对多等属性上，如果两个实体间没有任何关系，则不能用join。犹豫一对一、一对对、多对一、多对多等属性已经声明了外键连接条件，因此在HQL中的join 也不需要使用on指明连接条件，例如

select d,e fromDepartment d inner join d.employees e

employees是Department中的集合属性

Query by Criteria

QBC(Query ByCriteria)查询方式是Hibernate提供的“更加面向对象”的一种检索方式。QBC在条件查询上比HQL查询更为灵活，而且支持运行时动态生成查询语句。

在Hibernate应用中使用QBC查询通常经过3个步骤

  (1)使用Session实例的createCriteria()方法创建Criteria对象

  (2)使用工具类Restrictions的相关方法为Criteria对象设置查询对象

  (3)使用Criteria对象的list()方法执行查询，返回查询结果

 

Criteria c=session.createCriteria(Topic.class)                
           .add(Restrictions.gt("id",2))
           .add(Restrictions.lt("id",8))
          .add(Restrictions.like("title", "t_"))
           .createCriteria("category")
          .add(Restrictions.between("id", 3, 5)) ;
List list =c.list();

 

=            Restrictions.eq()                 等于

<>          Restrictions.not(Exprission.eq()) 不等于

>            Restrictions.gt()                 大于

>=           Restrictions.ge()                 大于等于

<            Restrictions.lt()                 小于

<=           Restrictions.le()                 小于等于

is null        Restrictions.isnull()              等于空值

is not null     Restrictions.isNotNull()          非空值

like            Restrictions.like()               字符串模式匹配

and            Restrictions.and()                逻辑与

and            Restrictions.conjunction()         逻辑与

or              Restrictions.or()                 逻辑或

or              Restrictions.disjunction()         逻辑或

not             Restrictions.not()                逻辑非

in(列表)         Restrictions.in()                等于列表中的某一个值

ont in(列表)      Restrictions.not(Restrictions.in())不等于列表中任意一个值

between x andy   Restrictions.between()           闭区间xy中的任意值

not between xand y Restrictions.not(Restrictions..between()) 小于值X或者大于值y

 

工具类Order提供设置排序方式

Order.asc(StringpropertyName) 升序排序

Order.desc(StringpropertyName) 降序排序

 

工具类Projections提供对查询结果进行统计与分组操作

Porjections.avg(StringpropertyName)              求某属性的平均值

Projections.count(StringpropertyName)          统计某属性的数量

Projections.countDistinct(StringpropertyName) 统计某属性的不同值的数量

Projections.groupProperty(StringpropertyName) 指定一组属性值

Projections.max(StringpropertyName)            某属性的最大值

Projections.min(StringpropertyName)             某属性的最小值

Projections.projectionList()                        创建一个新的projectionList对象

Projections.rowCount()                              查询结果集中记录的条数

Projections.sum(StringpropertyName)      返回某属性值的合计

 

复合查询就是在原有的查询基础上再进行查询。例如在顾客对定单的一对多关系中，在查询出所有的顾客对象后，希望在查询定单中money大于1000的定单对象。

Session session= HibernateSessionFactory.getSessionFactory().openSession();
Transaction ts =session.beginTransaction();
Criteria cuscriteria =session.createCriteria(Customer.class);
Criteria ordCriteria =cusCriteria.createCriteria("orders");
ordCriteria.add(Restrictions.gt("money",new Double(1000))); 
Iterator it =cusCriteria.list().iterator();
ts.commit();
HibernateSessionFactory.closeSession();

 

离线查询又叫DetachedCriteria查询，它可以在 Session 之外进行构造，只有在需要执行查询时才与 Session 绑定。

Query By Example

QBE查询就是检索与指定样本对象具有相同属性值的对象。因此QBE查询的关键就是样本对象的创建，样本对象中的所有非空属性均将作为查询条件。QBE查询的功能子集，虽然QBE没有QBC功能大，但是有些场合QBE使用起来更为方便。

工具类Example为Criteria对象指定样本对象作为查询条件

Customer c = newCustomer();
c.setCname("Hibernate"); 
Criteria criteria = session.createCriteria(Customer.class);
Criteria.add(Example.create(c)); 
Iterator it =criteria.list().iterator();

Native SQL

Session s =HibernateUtil.getSession();
  Query q = s.createSQLQuery("select *from user").addEntity(User.class);
  List<User> rs = q.list();

addEntity代表以某种实体类的形式返回List列表

命名查询

Query q =s.getNamedQuery("getUserById");
  q.setInteger("id", id);

 

注解方式

@NamedQuery(name= "all cat" ,query ="select * from Cat c")
@NamedNativeQuery(name= "all cat" ,query ="select * from tb_cat ")

 

配置方式

<hibernate-mapping>
    <class name="com.sy.vo.User" table="user" catalog="news">
    ……
    </class>
    <!-- 命名查询：定义查询条件 -->
    <query name="getUserById">
     <![CDATA[from User where id=:id]]>
    </query>
    <!-- 命名查询中使用sql，不推荐使用，影响跨数据库-->
    <sql-query name="getUserById2">
     <![CDATA[select * from User where]]>
    </sql-query> -->
</hibernate-mapping>

原文：http://blog.csdn.net/u012152619/article/details/44194061