hibernate查询

hibernate查询语言hql

在hql中关键字不区分大小写，但是属性和类名区分大小写

1、简单属性查询【重要】
* 单一属性查询，返回结果集属性列表，元素类型和实体类中相应的属性类型一致
* 多个属性查询,返回的集合元素是对象数组,数组元素的类型和对应的属性在实体类中的类型一致
   数组的长度取决与select中属性的个数
* 如果认为返回数组不够对象化，可以采用hql动态实例化Student对象
参见：QueryTest.java

2、实体对象查询【重要】
* N + 1问题，在默认情况下，使用query.iterate查询，有可以能出现N+1问题
   所谓的N+1是在查询的时候发出了N+1条sql语句
   1: 首先发出一条查询对象id列表的sql
   N: 根据id列表到缓存中查询，如果缓存中不存在与之匹配的数据，那么会根据id发出相应的sql语句
* list和iterate的区别？
   * list每次都会发出sql语句，list会向缓存中放入数据，而不利用缓存中的数据
   * iterate：在默认情况下iterate利用缓存数据，但如果缓存中不存在数据有可以能出现N+1问题
参见：QueryTest.java

3、条件查询【重要】
* 可以采用拼字符串的方式传递参数
* 可以采用 ？来传递参数（索引从0开始）
* 可以采用 :参数名 来传递参数
* 如果传递多个参数，可以采用setParamterList方法
* 在hql中可以使用数据库的函数，如：date_format
参见：QueryTest.java
   
4、hibernate也支持直接使用sql进行查询
参见：QueryTest.java

5、外置命名查询
* 在映射文件中采用<query>标签来定义hql
* 在程序中采用session.getNamedQuery()方法得到hql查询串
参见：Student.hbm.xml、QueryTest.java

6、查询过滤器
* 在映射文件中定义过滤器参数
* 在类的映射中使用这些参数
* 在程序中启用过滤器
参见：Student.hbm.xml、QueryTest.java

7、分页查询【重要】
* setFirstResult()，从0开始
* setMaxResults,每页显示多少条数据
参见：QueryTest.java
    
8、对象导航查询，在hql中采用 . 进行导航【重要】
参见：QueryTest.java

9、连接查询【重要】
* 内连
* 外连接（左连接/右连接）
参见：QueryTest.java

10、统计查询【重要】
参见：QueryTest.java

11、DML风格的操作（尽量少用，因为和缓存不同步）
参见：QueryTest.java




package com.wuyu.hibernate;

import java.text.SimpleDateFormat;
import java.util.Iterator;
import java.util.List;

import org.hibernate.Query;
import org.hibernate.Session;

import junit.framework.TestCase;

public class QueryTest extends TestCase {
/**
* 单一属性查询
*/
public void test1() {
   Session session = null;
   try {
    session = HibernateUtils.getSession();
    // 开启事物
    session.beginTransaction();
    // 返回结果集属性列表,元素类型和实体类中相应的属性类型一致
    List list = session.createQuery("select name from Student").list();
    for (Iterator it = list.listIterator(); it.hasNext();) {
     String name = (String) it.next();
     System.out.println(name);
    }
    // 提交事物
    session.getTransaction().commit();
   } catch (Exception e) {
    e.printStackTrace();
    // 回滚事物
    session.getTransaction().rollback();
   } finally {
    // 关闭SESSION
    HibernateUtils.closeSession(session);
   }
}

/**
* 多个属性查询
*/
public void test2() {
   Session session = null;
   try {
    session = HibernateUtils.getSession();
    // 开启事物
    session.beginTransaction();
    // 查询多个属性，其集合元素事对象数组，数组元素的类型与实体类中相应的属性类型一致
    List list = session.createQuery("select id,name from Student")
      .list();
    for (Iterator it = list.listIterator(); it.hasNext();) {
     Object[] obj = (Object[]) it.next();
     System.out.println("name=====" + obj[1]);
     System.out.println("id=========" + obj[0]);
    }
    // 提交事物
    session.getTransaction().commit();
   } catch (Exception e) {
    e.printStackTrace();
    // 回滚事物
    session.getTransaction().rollback();
   } finally {
    // 关闭SESSION
    HibernateUtils.closeSession(session);
   }
}

/**
* 返回实体对象
*/
public void test3() {
   Session session = null;
   try {
    session = HibernateUtils.getSession();
    // 开启事物
    session.beginTransaction();
    // 如果认为返回对象数组不够对象化，可以采用HQL动态实例化STUDENT对象
    List list = session.createQuery(
      "select new Student(id,name) from Student").list();
    for (Iterator it = list.listIterator(); it.hasNext();) {
     Student st = (Student) it.next();
     System.out.println(st.getId());
     System.out.println(st.getName());
    }
    // 提交事物
    session.getTransaction().commit();
   } catch (Exception e) {
    e.printStackTrace();
    // 回滚事物
    session.getTransaction().rollback();
   } finally {
    // 关闭SESSION
    HibernateUtils.closeSession(session);
   }
}

/**
* 使用别名进行查询
*/
public void test4() {
   Session session = null;
   try {
    session = HibernateUtils.getSession();
    // 开启事物
    session.beginTransaction();
    //
    List list = session.createQuery(
      "select new Student(s.id,s.name) from Student s").list();
    for (Iterator it = list.listIterator(); it.hasNext();) {
     Student st = (Student) it.next();
     System.out.println(st.getId());
     System.out.println(st.getName());
    }
    // 提交事物
    session.getTransaction().commit();
   } catch (Exception e) {
    e.printStackTrace();
    // 回滚事物
    session.getTransaction().rollback();
   } finally {
    // 关闭SESSION
    HibernateUtils.closeSession(session);
   }
}

/**
* 使用AS别名查询
*/
public void test5() {
   Session session = null;
   try {
    session = HibernateUtils.getSession();
    // 开启事物
    session.beginTransaction();
    //
    List list = session.createQuery(
      "select new Student(s.id,s.name) from Student as s").list();
    for (Iterator it = list.listIterator(); it.hasNext();) {
     Student st = (Student) it.next();
     System.out.println(st.getId());
     System.out.println(st.getName());
    }
    // 提交事物
    session.getTransaction().commit();
   } catch (Exception e) {
    e.printStackTrace();
    // 回滚事物
    session.getTransaction().rollback();
   } finally {
    // 关闭SESSION
    HibernateUtils.closeSession(session);
   }
}

/** *****************************注：TEST1,2,3,4,5都属于简单属性查询******************************** */

/**
* 实体对象查询
*/
public void test6() {
   Session session = null;
   try {
    session = HibernateUtils.getSession();
    // 开启事物
    session.beginTransaction();
    // 返回STUDENT 对象的集合 ，可以忽略SELECT
    List list = session.createQuery("from Student").list();
    for (Iterator it = list.listIterator(); it.hasNext();) {
     Student st = (Student) it.next();
     System.out.println(st.getName());
    }
    // 提交事物
    session.getTransaction().commit();
   } catch (Exception e) {
    e.printStackTrace();
    // 回滚事物
    session.getTransaction().rollback();
   } finally {
    // 关闭SESSION
    HibernateUtils.closeSession(session);
   }
}

/**
* 实体对象查询，可以使用别名
*/
public void test7() {
   Session session = null;
   try {
    session = HibernateUtils.getSession();
    // 开启事物
    session.beginTransaction();
    // 返回STUDENT 对象的集合 ，可以忽略SELECT
    List list = session.createQuery("from Student s").list();
    for (Iterator it = list.listIterator(); it.hasNext();) {
     Student st = (Student) it.next();
     System.out.println(st.getName());
    }
    // 提交事物
    session.getTransaction().commit();
   } catch (Exception e) {
    e.printStackTrace();
    // 回滚事物
    session.getTransaction().rollback();
   } finally {
    // 关闭SESSION
    HibernateUtils.closeSession(session);
   }
}

/**
* 实体对象查询 使用AS别名
*/
public void test8() {
   Session session = null;
   try {
    session = HibernateUtils.getSession();
    // 开启事物
    session.beginTransaction();
    // 返回STUDENT 对象的集合 ，可以忽略SELECT
    List list = session.createQuery("from Student as s").list();
    for (Iterator it = list.listIterator(); it.hasNext();) {
     Student st = (Student) it.next();
     System.out.println(st.getName());
    }
    // 提交事物
    session.getTransaction().commit();
   } catch (Exception e) {
    e.printStackTrace();
    // 回滚事物
    session.getTransaction().rollback();
   } finally {
    // 关闭SESSION
    HibernateUtils.closeSession(session);
   }
}

/**
* 实体对象查询 使用SELECT 必须使用别名
*/
public void test9() {
   Session session = null;
   try {
    session = HibernateUtils.getSession();
    // 开启事物
    session.beginTransaction();
    // 返回STUDENT 对象的集合
    List list = session.createQuery("select s from Student as s")
      .list();
    for (Iterator it = list.listIterator(); it.hasNext();) {
     Student st = (Student) it.next();
     System.out.println(st.getName());
    }
    // 提交事物
    session.getTransaction().commit();
   } catch (Exception e) {
    e.printStackTrace();
    // 回滚事物
    session.getTransaction().rollback();
   } finally {
    // 关闭SESSION
    HibernateUtils.closeSession(session);
   }
}

/**
* 不支持这种查询方式
*/
public void test10() {
   Session session = null;
   try {
    session = HibernateUtils.getSession();
    // 开启事物
    session.beginTransaction();
    // 返回STUDENT 对象的集合
    List list = session.createQuery("select * from Student as s")
      .list();
    for (Iterator it = list.listIterator(); it.hasNext();) {
     Student st = (Student) it.next();
     System.out.println(st.getName());
    }
    // 提交事物
    session.getTransaction().commit();
   } catch (Exception e) {
    e.printStackTrace();
    // 回滚事物
    session.getTransaction().rollback();
   } finally {
    // 关闭SESSION
    HibernateUtils.closeSession(session);
   }
}

/**
* 使用iterate查询实体对象
*/
public void test11() {
   Session session = null;
   try {
    session = HibernateUtils.getSession();
    // 开启事物
    session.beginTransaction();
    // 返回STUDENT 对象的集合,出现N+1问题.
    Iterator it = session.createQuery("select s from Student as s")
      .iterate();
    while (it.hasNext()) {
     Student st = (Student) it.next();
     System.out.println(st.getName());
    }
    // 提交事物
    session.getTransaction().commit();
   } catch (Exception e) {
    e.printStackTrace();
    // 回滚事物
    session.getTransaction().rollback();
   } finally {
    // 关闭SESSION
    HibernateUtils.closeSession(session);
   }
}

/**
* 使用iterate,list查询实体对象 * N + 1问题，在默认情况下，使用query.iterate查询，有可以能出现N+1问题
* 所谓的N+1是在查询的时候发出了N+1条sql语句 1: 首先发出一条查询对象id列表的sql N:
* 根据id列表到缓存中查询，如果缓存中不存在与之匹配的数据，那么会根据id发出相应的sql语句 list和iterate的区别？
* list每次都会发出sql语句，list会向缓存中放入数据，而不利用缓存中的数据
* iterate：在默认情况下iterate利用缓存数据，但如果缓存中不存在数据有可以能出现N+1问题
*/

public void test12() {
   Session session = null;
   try {
    session = HibernateUtils.getSession();
    // 开启事物
    session.beginTransaction();
    // 使用LIST借口
    List list = session.createQuery("select s from Student as s")
      .list();
    for (Iterator it = list.listIterator(); it.hasNext();) {
     Student st = (Student) it.next();
     System.out.println(st.getName());
    }
    System.out.println("---------------------------------------");

    // 使用iterate借口查询
    Iterator it = session.createQuery("select s from Student as s")
      .iterate();
    while (it.hasNext()) {
     Student st = (Student) it.next();
     System.out.println(st.getName());
    }
    // 提交事物
    session.getTransaction().commit();
   } catch (Exception e) {
    e.printStackTrace();
    // 回滚事物
    session.getTransaction().rollback();
   } finally {
    // 关闭SESSION
    HibernateUtils.closeSession(session);
   }
}

/** **************************注：test6-12属于实体对象查询*************************************** */

/**
* 条件查询, 拼字符串的方法
*/
public void test13() {
   Session session = null;
   try {
    session = HibernateUtils.getSession();
    // 开启事物
    session.beginTransaction();
    //
    Iterator it = session.createQuery(
      "select s.name from Student as s where s.name like '%1%'")
      .list().iterator();
    while (it.hasNext()) {
     System.out.println(it.next());
    }
    // 提交事物
    session.getTransaction().commit();
   } catch (Exception e) {
    e.printStackTrace();
    // 回滚事物
    session.getTransaction().rollback();
   } finally {
    // 关闭SESSION
    HibernateUtils.closeSession(session);
   }
}

/**
* 条件查询：采用占位符的方式
*/
public void test14() {
   Session session = null;
   try {
    session = HibernateUtils.getSession();
    // 开启事物
    session.beginTransaction();
    Query query = session
      .createQuery("select s.name from Student as s where s.name like ?");
    Iterator it = query.setParameter(0, "%1%").list().iterator();
    while (it.hasNext()) {
     System.out.println(it.next());
    }
    // 提交事物
    session.getTransaction().commit();
   } catch (Exception e) {
    e.printStackTrace();
    // 回滚事物
    session.getTransaction().rollback();
   } finally {
    // 关闭SESSION
    HibernateUtils.closeSession(session);
   }
}

/**
* 条件查询：采用参数名的方式查询
*/
public void test15() {
   Session session = null;
   try {
    session = HibernateUtils.getSession();
    // 开启事物
    session.beginTransaction();
    Query query = session
      .createQuery("select s.name from Student as s where s.name like :myname");
    Iterator it = query.setParameter("myname", "%1%").list().iterator();
    while (it.hasNext()) {
     System.out.println(it.next());
    }
    // 提交事物
    session.getTransaction().commit();
   } catch (Exception e) {
    e.printStackTrace();
    // 回滚事物
    session.getTransaction().rollback();
   } finally {
    // 关闭SESSION
    HibernateUtils.closeSession(session);
   }
}

/**
* 多个条件查询：采用参数名的方式查询
*/
public void test16() {
   Session session = null;
   try {
    session = HibernateUtils.getSession();
    // 开启事物
    session.beginTransaction();
    Query query = session
      .createQuery("select s.name from Student as s where s.name like :myname and s.id= :myid");
    Iterator it = query.setParameter("myname", "%1%").setParameter(
      "myid", 12).list().iterator();
    while (it.hasNext()) {
     System.out.println(it.next());
    }
    // 提交事物
    session.getTransaction().commit();
   } catch (Exception e) {
    e.printStackTrace();
    // 回滚事物
    session.getTransaction().rollback();
   } finally {
    // 关闭SESSION
    HibernateUtils.closeSession(session);
   }
}

/**
* 使用IN的条件查询
*/
public void test17() {
   Session session = null;
   try {
    session = HibernateUtils.getSession();
    // 开启事物
    session.beginTransaction();
    Query query = session
      .createQuery("select s.name from Student as s where s.name like :myname and s.id in(:myid)");
    Iterator it = query.setParameter("myname", "%1%").setParameterList(
      "myid", new Object[] { 1, 2, 3, 4, 5, 12 }).list()
      .iterator();
    while (it.hasNext()) {
     System.out.println(it.next());
    }
    // 提交事物
    session.getTransaction().commit();
   } catch (Exception e) {
    e.printStackTrace();
    // 回滚事物
    session.getTransaction().rollback();
   } finally {
    // 关闭SESSION
    HibernateUtils.closeSession(session);
   }
}

/**
* 查询2008-02的数据
*/
public void test18() {
   Session session = null;
   try {
    session = HibernateUtils.getSession();
    // 开启事物
    session.beginTransaction();

    // 可以使用数据库的函数
    Query query = session
      .createQuery("select s.createTime from Student as s where date_format(s.createTime,'%Y-%m') = ?");
    Iterator it = query.setParameter(0, "2008-02").list().iterator();
    while (it.hasNext()) {
     System.out.println(it.next());
    }
    // 提交事物
    session.getTransaction().commit();
   } catch (Exception e) {
    e.printStackTrace();
    // 回滚事物
    session.getTransaction().rollback();
   } finally {
    // 关闭SESSION
    HibernateUtils.closeSession(session);
   }
}

/**
* 查询时间段中的数据
*/
public void test19() {
   Session session = null;
   try {
    session = HibernateUtils.getSession();
    // 开启事物
    session.beginTransaction();

    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

    // 可以使用数据库的函数
    Query query = session
      .createQuery("select s.createTime from Student as s where s.createTime between ? and ?");
    Iterator it = query.setParameter(0,
      sdf.parse("2008-01-10 00:00:00")).setParameter(1,
      sdf.parse("2008-01-30 23:59:59")).list().iterator();
    while (it.hasNext()) {
     System.out.println(it.next());
    }
    // 提交事物
    session.getTransaction().commit();
   } catch (Exception e) {
    e.printStackTrace();
    // 回滚事物
    session.getTransaction().rollback();
   } finally {
    // 关闭SESSION
    HibernateUtils.closeSession(session);
   }
}

/** ********************test13-19条件查询********************************************* */

/**
* 原生SQL查询
*/
public void test20() {
   Session session = null;
   try {
    session = HibernateUtils.getSession();
    // 开启事物
    session.beginTransaction();
    // 返回结果集属性列表,元素类型和实体类中相应的属性类型一致
    List list = session.createSQLQuery("select name from t_student")
      .list();
    for (Iterator it = list.listIterator(); it.hasNext();) {
     String name = (String) it.next();
     System.out.println(name);
    }
    // 提交事物
    session.getTransaction().commit();
   } catch (Exception e) {
    e.printStackTrace();
    // 回滚事物
    session.getTransaction().rollback();
   } finally {
    // 关闭SESSION
    HibernateUtils.closeSession(session);
   }
}

/**
*
* 外置命名查询 在映射文件中采用<query>标签来定义hql 在程序中采用session.getNamedQuery()方法得到hql查询串
*/
public void test21() {
   Session session = null;
   try {
    session = HibernateUtils.getSession();
    // 开启事物
    session.beginTransaction();
    List list = session.getNamedQuery("searchStudents").list();
    for (Iterator it = list.listIterator(); it.hasNext();) {
     Student st = (Student) it.next();
     System.out.println(st.getName());
    }
    // 提交事物
    session.getTransaction().commit();
   } catch (Exception e) {
    e.printStackTrace();
    // 回滚事物
    session.getTransaction().rollback();
   } finally {
    // 关闭SESSION
    HibernateUtils.closeSession(session);
   }
}

/**
* 过滤查询
*
* 在映射文件中定义过滤器参数 在类的映射中使用这些参数 在程序中启用过滤器
*/
public void test22() {
   Session session = null;
   try {
    session = HibernateUtils.getSession();
    // 开启事物
    session.beginTransaction();
    // 启用过滤器，设置参数
    session.enableFilter("studentFilter").setParameter("myid", 10);
    List list = session.getNamedQuery("searchStudents").list();
    for (Iterator it = list.listIterator(); it.hasNext();) {
     Student st = (Student) it.next();
     System.out.println(st.getName());
     System.out.println(st.getId());
    }
    // 提交事物
    session.getTransaction().commit();
   } catch (Exception e) {
    e.printStackTrace();
    // 回滚事物
    session.getTransaction().rollback();
   } finally {
    // 关闭SESSION
    HibernateUtils.closeSession(session);
   }
}

/**
* 分页查询
*/
public void test23() {
   Session session = null;
   try {
    session = HibernateUtils.getSession();
    // 开启事物
    session.beginTransaction();
    // setFirstResult()，从0开始
    // setMaxResults,每页显示多少条数据
    List list = session.createQuery("from Student").setFirstResult(3)
      .setMaxResults(2).list();
    for (Iterator it = list.listIterator(); it.hasNext();) {
     Student st = (Student) it.next();
     System.out.println(st.getId());
    }
    // 提交事物
    session.getTransaction().commit();
   } catch (Exception e) {
    e.printStackTrace();
    // 回滚事物
    session.getTransaction().rollback();
   } finally {
    // 关闭SESSION
    HibernateUtils.closeSession(session);
   }
}

/**
* 对象导航查询
*/

public void test24() {
   Session session = null;
   try {
    session = HibernateUtils.getSession();
    // 开启事物
    session.beginTransaction();
    //
    List list = session
      .createQuery(
        "select s.name from Student s where s.classes.name like '%1%'")
      .list();
    for (Iterator it = list.listIterator(); it.hasNext();) {
     String name = (String) it.next();
     System.out.println(name);
    }
    // 提交事物
    session.getTransaction().commit();
   } catch (Exception e) {
    e.printStackTrace();
    // 回滚事物
    session.getTransaction().rollback();
   } finally {
    // 关闭SESSION
    HibernateUtils.closeSession(session);
   }
}

/**
* 统计查询
*/
public void test25() {
   Session session = null;
   try {
    session = HibernateUtils.getSession();
    // 开启事物
    session.beginTransaction();
    // List list = session.createQuery("select count(*) from Student")
    // .list();
    // for (Iterator it = list.listIterator(); it.hasNext();) {
    // Long count = (Long) it.next();
    // System.out.println(count);
    // }

    // 返回为单一值时
    Long count = (Long) session.createQuery(
      "select count(*) from Student").uniqueResult();
    System.out.println(count);
    // 提交事物
    session.getTransaction().commit();
   } catch (Exception e) {
    e.printStackTrace();
    // 回滚事物
    session.getTransaction().rollback();
   } finally {
    // 关闭SESSION
    HibernateUtils.closeSession(session);
   }
}

/**
* 内连接查询
*/
public void test26() {
   Session session = null;
   try {
    session = HibernateUtils.getSession();
    // 开启事物
    session.beginTransaction();
    //
    List list = session
      .createQuery(
        "select c.name,s.name from Student s inner join s.classes c")
      .list();
    for (Iterator it = list.listIterator(); it.hasNext();) {
     Object[] obj = (Object[]) it.next();
     System.out.println("name=====" + obj[1]);
     System.out.println("id=========" + obj[0]);
    }
    // 提交事物
    session.getTransaction().commit();
   } catch (Exception e) {
    e.printStackTrace();
    // 回滚事物
    session.getTransaction().rollback();
   } finally {
    // 关闭SESSION
    HibernateUtils.closeSession(session);
   }
}

/**
* 左外连接查询
*/
public void test27() {
   Session session = null;
   try {
    session = HibernateUtils.getSession();
    // 开启事物
    session.beginTransaction();
    // 查询所有的STUDENTS以及匹配的classes
    List list = session
      .createQuery(
        "select c.name,s.name from Classes c left join c.students s")
      .list();
    for (Iterator it = list.listIterator(); it.hasNext();) {
     Object[] obj = (Object[]) it.next();
     System.out.println("name=====" + obj[1]);
     System.out.println("id=========" + obj[0]);
    }
    // 提交事物
    session.getTransaction().commit();
   } catch (Exception e) {
    e.printStackTrace();
    // 回滚事物
    session.getTransaction().rollback();
   } finally {
    // 关闭SESSION
    HibernateUtils.closeSession(session);
   }
}

/**
*
*/
public void test28() {
   Session session = null;
   try {
    session = HibernateUtils.getSession();
    // 开启事物
    session.beginTransaction();
    // 查询所有的CLASSES以及匹配的STUDENTS
    List list = session
      .createQuery(
        "select c.name,s.name from Classes c right join c.students s")
      .list();
    for (Iterator it = list.listIterator(); it.hasNext();) {
     Object[] obj = (Object[]) it.next();
     System.out.println("name=====" + obj[1]);
     System.out.println("id=========" + obj[0]);
    }
    // 提交事物
    session.getTransaction().commit();
   } catch (Exception e) {
    e.printStackTrace();
    // 回滚事物
    session.getTransaction().rollback();
   } finally {
    // 关闭SESSION
    HibernateUtils.closeSession(session);
   }
}
}