在Java的Hibernate框架中对数据库数据进行查询操作

hibernate查询语言（hql）是一种面向对象的查询语言，类似于sql，但不是对表和列操作，hql适用于持久对象和它们的属性。 hql查询由hibernate转换成传统的sql查询，这在圈上的数据库执行操作。

虽然可以直接使用sql语句和hibernate使用原生sql，但建议使用hql尽可能避免数据库可移植性的麻烦，并采取hibernate的sql生成和缓存策略的优势。

都像select，from和where等关键字不区分大小写，但如表名和列名的属性是区分在hql敏感。

from 语句
使用from子句，如果要加载一个完整的持久化对象到内存中。下面是一个使用from子句的简单的语法：

string hql = "from employee";
query query = session.createquery(hql);
list results = query.list();

如果需要完全限定在hql一个类名，只需指定如下的包和类名：

string hql = "from com.hibernatebook.criteria.employee";
query query = session.createquery(hql);
list results = query.list();

as 语句
as子句可以用来别名分配给类中的hql查询，特别是当有很长的查询。例如，我们前面简单的例子是以下几点：

string hql = "from employee as e";
query query = session.createquery(hql);
list results = query.list();

as关键字是可选的，也可以直接在之后的类名指定别名，如下所示：

string hql = "from employee e";
query query = session.createquery(hql);
list results = query.list();

select 子句
select子句提供了更多的控制权比from子句的结果集。如果想获得对象而不是整个对象的几个属性，使用select子句。下面是一个使用select语句来获取employee对象只是first_name字段的简单的语法：

string hql = "select e.firstname from employee e";
query query = session.createquery(hql);
list results = query.list();

值得注意的是在这里，employee.firstname是employee对象的一个属性，而不是employee表的一个字段。

where 子句
如果想缩小了从存储返回的特定对象，可以使用where子句。下面是一个使用where子句的简单的语法：

string hql = "from employee e where e.id = 10";
query query = session.createquery(hql);
list results = query.list();

order by 子句
若要排序hql查询的结果，将需要使用order by子句。您可以在结果集按升序（asc）或降序（desc）通过在对象的任何属性排序结果。下面是一个使用order by子句的简单的语法：

string hql = "from employee e where e.id > 10 order by e.salary desc";
query query = session.createquery(hql);
list results = query.list();

如果想通过一个以上的属性进行排序，你会仅仅是额外的属性添加到由子句用逗号隔开，如下所示的命令的结尾：

string hql = "from employee e where e.id > 10 " +
       "order by e.firstname desc, e.salary desc ";
query query = session.createquery(hql);
list results = query.list();

group by 子句
该子句允许从hibernate的它基于属性的值的数据库和组提取信息，并且通常使用结果包括总值。下面是一个使用group by子句的语法很简单：

string hql = "select sum(e.salary), e.firtname from employee e " +
       "group by e.firstname";
query query = session.createquery(hql);
list results = query.list();

使用命名参数
hibernate命名在其hql查询参数支持。这使得编写接受来自用户的输入容易，不必对sql注入攻击防御hql查询。下面是一个使用命名参数的简单的语法：

string hql = "from employee e where e.id = :employee_id";
query query = session.createquery(hql);
query.setparameter("employee_id",10);
list results = query.list();

update 子句
批量更新是新的hql与hibernate3，以及不同的删除工作，在hibernate 3和hibernate2一样。 query接口现在包含一个名为executeupdate()方法用于执行hql update或delete语句。

在update子句可以用于更新一个或多个对象中的一个或多个属性。下面是一个使用update子句的简单的语法：

string hql = "update employee set salary = :salary " + 
       "where id = :employee_id";
query query = session.createquery(hql);
query.setparameter("salary", 1000);
query.setparameter("employee_id", 10);
int result = query.executeupdate();
system.out.println("rows affected: " + result);

delete 子句
delete子句可以用来删除一个或多个对象。下面是一个使用delete子句的简单的语法：

string hql = "delete from employee " + 
       "where id = :employee_id";
query query = session.createquery(hql);
query.setparameter("employee_id", 10);
int result = query.executeupdate();
system.out.println("rows affected: " + result);

insert 子句
hql支持insert into子句中只记录在那里可以插入从一个对象到另一个对象。以下是使用insert into子句的简单的语法：

string hql = "insert into employee(firstname, lastname, salary)" + 
       "select firstname, lastname, salary from old_employee";
query query = session.createquery(hql);
int result = query.executeupdate();
system.out.println("rows affected: " + result);

聚合方法
hql支持多种聚合方法，类似于sql。他们工作在hql同样的方式在sql和下面的可用功能列表：

distinct关键字只计算在该行设定的唯一值。下面的查询将只返回唯一的计数：

string hql = "select count(distinct e.firstname) from employee e";
query query = session.createquery(hql);
list results = query.list();

使用查询分页
有用于分页查询接口的两个方法。

• query setfirstresult(int startposition)
• query setmaxresults(int maxresult)

采用上述两种方法一起，可以在网站或swing应用程序构建一个分页组件。下面是例子，可以扩展来获取10行：

string hql = "from employee";
query query = session.createquery(hql);
query.setfirstresult(1);
query.setmaxresults(10);
list results = query.list();

查询条件
hibernate提供了操作对象，并依次数据在rdbms表可用的备用方式。其中一个方法是标准的api，它允许你建立一个标准的查询对象编程，可以套用过滤规则和逻辑条件。
hibernate的session接口提供了可用于创建一个返回的持久化对象的类的实例时，应用程序执行一个条件查询一个criteria对象createcriteria()方法。

以下是最简单的一个条件查询的例子是将简单地返回对应于employee类的每个对象。

criteria cr = session.createcriteria(employee.class);
list results = cr.list();

限制与标准：
可以使用add（）方法可用于criteria对象添加限制条件查询。下面是例子增加一个限制与薪水返回的记录是等于2000：

criteria cr = session.createcriteria(employee.class);
cr.add(restrictions.eq("salary", 2000));
list results = cr.list();

以下是几个例子覆盖不同的场景，并且可以根据要求使用：

criteria cr = session.createcriteria(employee.class);

// to get records having salary more than 2000
cr.add(restrictions.gt("salary", 2000));

// to get records having salary less than 2000
cr.add(restrictions.lt("salary", 2000));

// to get records having fistname starting with zara
cr.add(restrictions.like("firstname", "zara%"));

// case sensitive form of the above restriction.
cr.add(restrictions.ilike("firstname", "zara%"));

// to get records having salary in between 1000 and 2000
cr.add(restrictions.between("salary", 1000, 2000));

// to check if the given property is null
cr.add(restrictions.isnull("salary"));

// to check if the given property is not null
cr.add(restrictions.isnotnull("salary"));

// to check if the given property is empty
cr.add(restrictions.isempty("salary"));

// to check if the given property is not empty
cr.add(restrictions.isnotempty("salary"));
可以创建and或or使用logicalexpression限制如下条件：

criteria cr = session.createcriteria(employee.class);

criterion salary = restrictions.gt("salary", 2000);
criterion name = restrictions.ilike("firstnname","zara%");

// to get records matching with or condistions
logicalexpression orexp = restrictions.or(salary, name);
cr.add( orexp );


// to get records matching with and condistions
logicalexpression andexp = restrictions.and(salary, name);
cr.add( andexp );

list results = cr.list();

虽然上述所有条件，可以直接使用hql在前面的教程中介绍。

分页使用标准：
还有的标准接口，用于分页的两种方法。

• public criteria setfirstresult(int firstresult)
• public criteria setmaxresults(int maxresults)

采用上述两种方法一起，我们可以在我们的网站或swing应用程序构建一个分页组件。下面是例子，可以扩展来每次获取10行：

criteria cr = session.createcriteria(employee.class);
cr.setfirstresult(1);
cr.setmaxresults(10);
list results = cr.list();

排序的结果：
标准的api提供了org.hibernate.criterion.order类排序按升序或降序排列你的结果集，根据对象的属性。这个例子演示了如何使用order类的结果集进行排序：

criteria cr = session.createcriteria(employee.class);
// to get records having salary more than 2000
cr.add(restrictions.gt("salary", 2000));

// to sort records in descening order
crit.addorder(order.desc("salary"));

// to sort records in ascending order
crit.addorder(order.asc("salary"));

list results = cr.list();

预测与聚合：
该criteria api提供了一个org.hibernate.criterion.projections类可用于获取平均值，最大值或最小值的属性值。projections类是类似于类限制，因为它提供了几个静态工厂方法用于获得projection 实例。  provides the

以下是涉及不同的方案的一些例子，可按规定使用：

criteria cr = session.createcriteria(employee.class);

// to get total row count.
cr.setprojection(projections.rowcount());

// to get average of a property.
cr.setprojection(projections.avg("salary"));

// to get distinct count of a property.
cr.setprojection(projections.countdistinct("firstname"));

// to get maximum of a property.
cr.setprojection(projections.max("salary"));

// to get minimum of a property.
cr.setprojection(projections.min("salary"));

// to get sum of a property.
cr.setprojection(projections.sum("salary"));

criteria queries 例子：
考虑下面的pojo类：

public class employee {
  private int id;
  private string firstname; 
  private string lastname;  
  private int salary; 

  public employee() {}
  public employee(string fname, string lname, int salary) {
   this.firstname = fname;
   this.lastname = lname;
   this.salary = salary;
  }
  public int getid() {
   return id;
  }
  public void setid( int id ) {
   this.id = id;
  }
  public string getfirstname() {
   return firstname;
  }
  public void setfirstname( string first_name ) {
   this.firstname = first_name;
  }
  public string getlastname() {
   return lastname;
  }
  public void setlastname( string last_name ) {
   this.lastname = last_name;
  }
  public int getsalary() {
   return salary;
  }
  public void setsalary( int salary ) {
   this.salary = salary;
  }
}

让我们创建下面的employee表来存储employee对象：

create table employee (
  id int not null auto_increment,
  first_name varchar(20) default null,
  last_name varchar(20) default null,
  salary   int default null,
  primary key (id)
);

以下将被映射文件。

<?xml version="1.0" encoding="utf-8"?>
<!doctype hibernate-mapping public 
 "-//hibernate/hibernate mapping dtd//en"
 "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> 

<hibernate-mapping>
  <class name="employee" table="employee">
   <meta attribute="class-description">
     this class contains the employee detail. 
   </meta>
   <id name="id" type="int" column="id">
     <generator class="native"/>
   </id>
   <property name="firstname" column="first_name" type="string"/>
   <property name="lastname" column="last_name" type="string"/>
   <property name="salary" column="salary" type="int"/>
  </class>
</hibernate-mapping>

最后，我们将创建应用程序类的main（）方法来运行，我们将使用criteria查询的应用程序：

import java.util.list; 
import java.util.date;
import java.util.iterator; 
 
import org.hibernate.hibernateexception; 
import org.hibernate.session; 
import org.hibernate.transaction;
import org.hibernate.sessionfactory;
import org.hibernate.criteria;
import org.hibernate.criterion.restrictions;
import org.hibernate.criterion.projections;
import org.hibernate.cfg.configuration;

public class manageemployee {
  private static sessionfactory factory; 
  public static void main(string[] args) {
   try{
     factory = new configuration().configure().buildsessionfactory();
   }catch (throwable ex) { 
     system.err.println("failed to create sessionfactory object." + ex);
     throw new exceptionininitializererror(ex); 
   }
   manageemployee me = new manageemployee();

   /* add few employee records in database */
   integer empid1 = me.addemployee("zara", "ali", 2000);
   integer empid2 = me.addemployee("daisy", "das", 5000);
   integer empid3 = me.addemployee("john", "paul", 5000);
   integer empid4 = me.addemployee("mohd", "yasee", 3000);

   /* list down all the employees */
   me.listemployees();

   /* print total employee's count */
   me.countemployee();

   /* print toatl salary */
   me.totalsalary();
  }
  /* method to create an employee in the database */
  public integer addemployee(string fname, string lname, int salary){
   session session = factory.opensession();
   transaction tx = null;
   integer employeeid = null;
   try{
     tx = session.begintransaction();
     employee employee = new employee(fname, lname, salary);
     employeeid = (integer) session.save(employee); 
     tx.commit();
   }catch (hibernateexception e) {
     if (tx!=null) tx.rollback();
     e.printstacktrace(); 
   }finally {
     session.close(); 
   }
   return employeeid;
  }

  /* method to read all the employees having salary more than 2000 */
  public void listemployees( ){
   session session = factory.opensession();
   transaction tx = null;
   try{
     tx = session.begintransaction();
     criteria cr = session.createcriteria(employee.class);
     // add restriction.
     cr.add(restrictions.gt("salary", 2000));
     list employees = cr.list();

     for (iterator iterator = 
              employees.iterator(); iterator.hasnext();){
      employee employee = (employee) iterator.next(); 
      system.out.print("first name: " + employee.getfirstname()); 
      system.out.print(" last name: " + employee.getlastname()); 
      system.out.println(" salary: " + employee.getsalary()); 
     }
     tx.commit();
   }catch (hibernateexception e) {
     if (tx!=null) tx.rollback();
     e.printstacktrace(); 
   }finally {
     session.close(); 
   }
  }
  /* method to print total number of records */
  public void countemployee(){
   session session = factory.opensession();
   transaction tx = null;
   try{
     tx = session.begintransaction();
     criteria cr = session.createcriteria(employee.class);

     // to get total row count.
     cr.setprojection(projections.rowcount());
     list rowcount = cr.list();

     system.out.println("total coint: " + rowcount.get(0) );
     tx.commit();
   }catch (hibernateexception e) {
     if (tx!=null) tx.rollback();
     e.printstacktrace(); 
   }finally {
     session.close(); 
   }
  }
 /* method to print sum of salaries */
  public void totalsalary(){
   session session = factory.opensession();
   transaction tx = null;
   try{
     tx = session.begintransaction();
     criteria cr = session.createcriteria(employee.class);

     // to get total salary.
     cr.setprojection(projections.sum("salary"));
     list totalsalary = cr.list();

     system.out.println("total salary: " + totalsalary.get(0) );
     tx.commit();
   }catch (hibernateexception e) {
     if (tx!=null) tx.rollback();
     e.printstacktrace(); 
   }finally {
     session.close(); 
   }
  }
}

编译和执行：
下面是步骤来编译并运行上述应用程序。请确保您已在进行的编译和执行之前，适当地设置path和classpath。

• 创建hibernate.cfg.xml配置文件中配置章节解释。
• 创建employee.hbm.xml映射文件，如上图所示。
• 创建employee.java源文件，如上图所示，并编译它。
• 创建manageemployee.java源文件，如上图所示，并编译它。
• 执行manageemployee二进制运行程序.

会得到以下结果，并记录将创建在employee表中。

$java manageemployee

.......various log messages will display here........

first name: daisy last name: das salary: 5000
first name: john last name: paul salary: 5000
first name: mohd last name: yasee salary: 3000
total coint: 4
total salary: 15000

如果检查employee表，它应该记录如下：

mysql> select * from employee;

+----+------------+-----------+--------+
| id | first_name | last_name | salary |
+----+------------+-----------+--------+
| 14 | zara    | ali    |  2000 |
| 15 | daisy   | das    |  5000 |
| 16 | john    | paul   |  5000 |
| 17 | mohd    | yasee   |  3000 |
+----+------------+-----------+--------+
4 rows in set (0.00 sec)