检索策略
Hibernate的Session在加载一个Java对象时，可以将与这个对象相关联的其他Java对象都加载到缓存中，以便程序及时调用。但有些情况下，我们不需要加载太多无用的对象到缓存中，一来这样会撑爆内存，二来增加了访问数据库的次数。所以为了合理的使用缓存，Hibernate提供了几种检索策略来供用户选择。
几种策略简介
<1>.Hibernate的检索策略
在Hibernate中主要有三种检索策略，它们是立即检索策略、延迟检索策略、左外连接检索策略。
下面分别介绍一下这三种检索策略。
立即检索策略
采用立即检索策略，会将被检索的对象，以及和这个对象关联的一对多对象都加载到缓存中。Session的get方法就使用的立即检索策略。
优点：频繁使用的关联对象能够被加载到缓存中。
缺点：1、占用内存。2、Select语句过多。
<2>.延迟检索策略：
采用延迟检索策略，就不会加载关联对象的内容。直到第一次调用关联对象时，才去加载关联对象。在不涉及关联类操作时，延迟检索策略只适用于Session的load方法。涉及关联类操作时，延迟检索策略也能够适用于get，list等操作。
在类级别操作时(也就是只涉及一张表时)， 延迟检索策略，只加载类的OID不加载类的其他属性，只用当第一次访问其他属性时，才会访问数据库去加载内容。
在关联级别操作时(也就是有一对多,多对多…关联关系时, 涉及多张表时)，延迟检索策略，只加载类本身，不加载关联类，直到第一次调用关联对象时，才去加载关联对象
程序的默认模式都是用延迟加载策略。如果需要指定使用延迟加载策略。在配置文件中设置<class>的lazy=true，<set>的lazy=true或extra（增强延迟）<many-to-one>的lazy=proxy和no-proxy。
优点：由程序决定加载哪些类和内容，避免了大量无用的sql语句和内存消耗。
缺点：在Session关闭后，就不能访问关联类对象了。强行访问就会发生赖加载异常, 所以需要确保在Session.close方法前，调用关联对象。
<3>.左外连接检索策略：
采用左外连接检索，能够使用Sql的外连接查询，将需要加载的关联对象加载在缓存中。<set>fetch设置为join，<many-to-one>的fetch设置为 join
fetch除join取值外, 还有select和subselect的取值,它们决定了发起的sql语句的形式, 分开独立的select查询, 还是子查询, 还是外连接查询.
优点：1．对应用程序完全透明，不管对象处于持久化状态，还是游离状态，应用程序都可以方便的从一个对象导航到与它关联的对象。2．使用了外连接，select语句数目少。
缺点：1．可能会加载应用程序不需要访问的对象，白白浪费许多内存空间。2．复杂的数据库表连接也会影响检索性能。
batch-size属性：
无论是立即检索还是延迟检索，都可以指定关联查询的数量，这就需要使用batch-size属性来指定，指定关联查询数量，以减少批量检索的数据数目。从而提高检索的性能。
检索策略举例与比较
在一个类的情况下，比较立即检索和延迟检索:
<class>标签上默认模式下: load方法,和<class lazy="false">会话的load方法。
什么时候用懒加载,什么时候不用: 如果程序加载一个对象的目的是为了访问它的某个属性, 就用立即加载, 如果加载对象是为了拿到它的应用, 就用延迟加载!
在关联级别操作时(也就是有一对多,多对多…关联关系时, 涉及多张表时)，延迟检索策略，只加载类本身，不加载关联类，直到第一次调用关联对象时，才去加载关联对象， 这里主要说一下lazy=extra（增强延迟）表示，加载对象的时间，能延迟就尽可能的延迟，比lazy=true进一步的延迟。
例1：比较立即加载与延迟加载，用前面学的Teacher,Student双向多对一的例子为基础测试
本多对一关联表，由学生维护关系，老师用<set>属性来包果所有他带的学生，所以延迟（加载）性在该标签内设置
1例.我不在标签中设置lazy=“true”,即不显示的写出它，默认为lazy=“true",看看get,load方法的sql语句执行情况
<hibernate-mapping package="cn.ybzy.hibernatedemo.model">
<class name="Teacher" table="t_teacher">
<id name="id" type="int">
<column name="id" />
<generator class="native" />
</id>
<property name="tname" type="java.lang.String">
<column name="t_name" />
</property>
<set name="students" table="t_students" inverse="true">
<key>
<column name="teacher_id" />
</key>
<one-to-many class="Student" />
</set>
</class>
</hibernate-mapping>
测试：先创建8个学生（zs1-4,ls1-4)，4个老师(yx1-4),再我们获取第一个老师，和它学生的情况
@Test //检索策略测试
public void selectpolicyTest() {
//先加八个学生（zs1-4,ls1-4),四个老师(yx1-4)
/*Teacher teacher =new Teacher();
teacher.setTname("yx4");
Student student1=new Student();
student1.setSname("zs4");
student1.setTeacher(teacher);
Student student2=new Student();
student2.setSname("ls4");
student2.setTeacher(teacher);
Set<Student> students = new HashSet<>();
students.add(student1);
students.add(student2);
teacher.setStudents(students);
session.save(teacher);
session.save(student1);
session.save(student2);*/
Teacher teacher=session.get(Teacher.class, 1);
//Teacher teacher=session.load(Teacher.class, 1);
teacher.getStudents();
Sysout.out.println(teacher);
}
－－－－－－－－－-－－-－－--－－-－--－－－－－--－--－-－－－－－－－－－－－－－－－－－
Hibernate:
select
teacher0_.id as id1_1_0_,
teacher0_.t_name as t_name2_1_0_
from
t_teacher teacher0_
where
teacher0_.id=?
//System.out.println(teacher);发送的sql语句，说明懒加载没用到关联类时不加载它
Hibernate:
select
teacher0_.id as id1_1_0_,
teacher0_.t_name as t_name2_1_0_
from
t_teacher teacher0_
where
teacher0_.id=?
上面的代码，get,load一样效果
Teacher teacher=session.get(Teacher.class, 1);
//Teacher teacher=session.load(Teacher.class, 1);
System.out.println(teacher.getStudents());
System.out.println(teacher);
-------------------------------------------------------------------------------------
Hibernate:
select
teacher0_.id as id1_1_0_,
teacher0_.t_name as t_name2_1_0_
from
t_teacher teacher0_
where
teacher0_.id=?
Hibernate:
select
students0_.teacher_id as teacher_3_0_0_,
students0_.id as id1_0_0_,
students0_.id as id1_0_1_,
students0_.s_name as s_name2_0_1_,
students0_.teacher_id as teacher_3_0_1_
from
student students0_
where
students0_.teacher_id=?
[Student [id=1, sname=zs1], Student [id=2, sname=ls1]]
//System.out.println(teacher);发送的sql语句，说明懒加载没用到关联类时不加载它
Hibernate:
select
teacher0_.id as id1_1_0_,
teacher0_.t_name as t_name2_1_0_
from
t_teacher teacher0_
where
teacher0_.id=?
Teacher [id=1, tname=yx1]
上面的代码get,load一样效果
2例：我在<set>标签中设置lazy=“false”,即显示的写出它，看看get,load方法的sql语句执行情况
Teacher teacher=session.get(Teacher.class, 1);
//Teacher teacher=session.load(Teacher.class, 1);
System.out.println(teacher);
----------------------------------------------------------------------------
//没有设置懒加载性能，即get方法，即使没有要查询关联对象，也会立即载它
//load也会失去懒加载性质，此时发送的sql语句和get方法一样
Hibernate:
select
teacher0_.id as id1_1_0_,
teacher0_.t_name as t_name2_1_0_
from
t_teacher teacher0_
where
teacher0_.id=?
Hibernate:
select
students0_.teacher_id as teacher_3_0_0_,
students0_.id as id1_0_0_,
students0_.id as id1_0_1_,
students0_.s_name as s_name2_0_1_,
students0_.teacher_id as teacher_3_0_1_
from
student students0_
where
students0_.teacher_id=?
Teacher [id=1, tname=yx1]
3.例：我在<set>标签中设置lazy=“true”,即显示的写出它，看看get,load方法的sql语句执行情况
//用上面的经测试，和上面的效果一样
Teacher teacher=session.get(Teacher.class, 1);
System.out.println("学生有："+teacher.getStudents().size()+"个");
-------------------------------------------------------------------------------------
Hibernate:
select
teacher0_.id as id1_1_0_,
teacher0_.t_name as t_name2_1_0_
from
t_teacher teacher0_
where
teacher0_.id=?
Hibernate:
select
students0_.teacher_id as teacher_3_0_0_,
students0_.id as id1_0_0_,
students0_.id as id1_0_1_,
students0_.s_name as s_name2_0_1_,
students0_.teacher_id as teacher_3_0_1_
from
student students0_
where
students0_.teacher_id=?
学生有：2个
4.例：.lazy=extra（增强延迟）实验
<set name="students" table="t_students" inverse="true" lazy="extra">
Teacher teacher=session.get(Teacher.class, 1);
System.out.println("学生有："+teacher.getStudents().size()+"个");
----------------------------------------------------------------------------------
Hibernate:
select
teacher0_.id as id1_1_0_,
teacher0_.t_name as t_name2_1_0_
from
t_teacher teacher0_
where
teacher0_.id=?
Hibernate:
select
count(id)
from
student
where
teacher_id =?
学生有：2个
注意一下，这里的增强延迟性用上了后，连关联学生查询sql语句都不用了，只用了个count方法统计记录数了
5例：lazy=true的时候， 也可以让延迟失效，Hibernate.initialize()这个静态方法
Teacher teacher=session.get(Teacher.class, 1);
Hibernate.initialize(teacher.getStudents());
-----------------------------------------------------------------------------------------------------------
Hibernate:
select
teacher0_.id as id1_1_0_,
teacher0_.t_name as t_name2_1_0_
from
t_teacher teacher0_
where
teacher0_.id=?
Hibernate:
select
students0_.teacher_id as teacher_3_0_0_,
students0_.id as id1_0_0_,
students0_.id as id1_0_1_,
students0_.s_name as s_name2_0_1_,
students0_.teacher_id as teacher_3_0_1_
from
student students0_
where
students0_.teacher_id=?
上面的代码执行效果，与1例，比较发现，这里加载了Student关联对象了，而1例中，只加载了Teacher对象，说明此上面的代码initial(xxx)使懒加载（延[迟性）失效了。这种方式适合在大环境是延迟性，局部要用到立即加载的情况下。*
6例.batch-size＝“xxx”实验,没有batch-size, 有几个老师发起几条sql语句, 配置batch-size, 就会发起这个值整数倍的sql语句
无论是立即检索还是延迟检索，都可以指定关联查询的数量，这就需要使用batch-size属性来指定，指定关联查询数量，以减少批量检索的数据数目。从而提高检索的性能。
<set name="students" table="t_students" inverse="true"
lazy="true" batch-size="4">
//batch-size=“xxx" 测试
String hql="from Teacher";
Query<Teacher> query=session.createQuery(hql);
List<Teacher> lists=query.list();
for(Teacher t:lists) {
System.out.println(t.getStudents());
}
-------------------------------------------------------------------------------
Hibernate:
select
teacher0_.id as id1_1_,
teacher0_.t_name as t_name2_1_
from
t_teacher teacher0_
Hibernate:
select
students0_.teacher_id as teacher_3_0_1_,
students0_.id as id1_0_1_,
students0_.id as id1_0_0_,
students0_.s_name as s_name2_0_0_,
students0_.teacher_id as teacher_3_0_0_
from
student students0_
where
students0_.teacher_id in (
?, ?, ?, ?
)
[Student [id=1, sname=zs1], Student [id=2, sname=ls1]]
[Student [id=3, sname=zs2], Student [id=4, sname=ls2]]
[Student [id=6, sname=ls3], Student [id=5, sname=zs3]]
[Student [id=7, sname=zs4], Student [id=8, sname=ls4]]
另看一个，不设置batch-size的实验
<set name="students" table="t_students" inverse="true"
lazy="true">
//batch-size=“xxx" 测试
String hql="from Teacher";
Query<Teacher> query=session.createQuery(hql);
List<Teacher> lists=query.list();
for(Teacher t:lists) {
System.out.println(t.getStudents());
}
-------------------------------------------------------------------------------
Hibernate:
select
teacher0_.id as id1_1_,
teacher0_.t_name as t_name2_1_
from
t_teacher teacher0_
Hibernate:
select
students0_.teacher_id as teacher_3_0_0_,
students0_.id as id1_0_0_,
students0_.id as id1_0_1_,
students0_.s_name as s_name2_0_1_,
students0_.teacher_id as teacher_3_0_1_
from
student students0_
where
students0_.teacher_id=?
[Student [id=2, sname=ls1], Student [id=1, sname=zs1]]
Hibernate:
select
students0_.teacher_id as teacher_3_0_0_,
students0_.id as id1_0_0_,
students0_.id as id1_0_1_,
students0_.s_name as s_name2_0_1_,
students0_.teacher_id as teacher_3_0_1_
from
student students0_
where
students0_.teacher_id=?
[Student [id=3, sname=zs2], Student [id=4, sname=ls2]]
Hibernate:
select
students0_.teacher_id as teacher_3_0_0_,
students0_.id as id1_0_0_,
students0_.id as id1_0_1_,
students0_.s_name as s_name2_0_1_,
students0_.teacher_id as teacher_3_0_1_
from
student students0_
where
students0_.teacher_id=?
[Student [id=6, sname=ls3], Student [id=5, sname=zs3]]
Hibernate:
select
students0_.teacher_id as teacher_3_0_0_,
students0_.id as id1_0_0_,
students0_.id as id1_0_1_,
students0_.s_name as s_name2_0_1_,
students0_.teacher_id as teacher_3_0_1_
from
student students0_
where
students0_.teacher_id=?
[Student [id=7, sname=zs4], Student [id=8, sname=ls4]]
有关fetch实验，包括左外连接检索策略
select—>subselect,把in(?,?)语句变成了子查询!从原来的发起4条sql变成1条了! 这个时候, lazy有效, batch-size失效!
取值是join时,不能和batch-size属性一起用, 加载一这端对象时,它会用左外连接将关联对象一起加载进来 ! 而且这时lazy属性没有作用了!
7例：取值为: “select”(默认值)和"subselect"时发起的sql语句有什么不同?
fetch=“select”
<set name="students" table="t_students" inverse="true" lazy="true" fetch="select">
String hql="from Teacher";
Query<Teacher> query=session.createQuery(hql);
List<Teacher> lists=query.list();
for(Teacher t:lists) {
System.out.println("该老师有"+t.getStudents().size()+"个学生");
}
-------------------------------------------------------------------------------
Hibernate:
select
teacher0_.id as id1_1_,
teacher0_.t_name as t_name2_1_
from
t_teacher teacher0_
Hibernate:
select
students0_.teacher_id as teacher_3_0_0_,
students0_.id as id1_0_0_,
students0_.id as id1_0_1_,
students0_.s_name as s_name2_0_1_,
students0_.teacher_id as teacher_3_0_1_
from
student students0_
where
students0_.teacher_id=?
该老师有2个学生
Hibernate:
select
students0_.teacher_id as teacher_3_0_0_,
students0_.id as id1_0_0_,
students0_.id as id1_0_1_,
students0_.s_name as s_name2_0_1_,
students0_.teacher_id as teacher_3_0_1_
from
student students0_
where
students0_.teacher_id=?
该老师有2个学生
Hibernate:
select
students0_.teacher_id as teacher_3_0_0_,
students0_.id as id1_0_0_,
students0_.id as id1_0_1_,
students0_.s_name as s_name2_0_1_,
students0_.teacher_id as teacher_3_0_1_
from
student students0_
where
students0_.teacher_id=?
该老师有2个学生
Hibernate:
select
students0_.teacher_id as teacher_3_0_0_,
students0_.id as id1_0_0_,
students0_.id as id1_0_1_,
students0_.s_name as s_name2_0_1_,
students0_.teacher_id as teacher_3_0_1_
from
student students0_
where
students0_.teacher_id=?
该老师有2个学生
fetch=“subselect”
<set name="students" table="t_students" inverse="true" lazy="true" fetch="subselect">
String hql="from Teacher";
Query<Teacher> query=session.createQuery(hql);
List<Teacher> lists=query.list();
for(Teacher t:lists) {
System.out.println("该老师有"+t.getStudents().size()+"个学生");
}
-------------------------------------------------------------------------------
Hibernate:
select
teacher0_.id as id1_1_,
teacher0_.t_name as t_name2_1_
from
t_teacher teacher0_
Hibernate:
select
students0_.teacher_id as teacher_3_0_1_,
students0_.id as id1_0_1_,
students0_.id as id1_0_0_,
students0_.s_name as s_name2_0_0_,
students0_.teacher_id as teacher_3_0_0_
from
student students0_
where
students0_.teacher_id in (
select
teacher0_.id
from
t_teacher teacher0_
)
该老师有2个学生
该老师有2个学生
该老师有2个学生
该老师有2个学生
8例：fetch="join"左外连接查询
//hql语法的sql名，在fetch="join“,后面的配置无效，所以join测试不能用hql查询
Teacher teacher = session.load(Teacher.class, 1);
System.out.println(teacher.getStudents().size());
-------------------------------------------------------------------------
/*只有一条sql查询语锯，没有了上面的共公的
select
teacher0_.id as id1_1_,
teacher0_.t_name as t_name2_1_
from
t_teacher teacher0_*/
Hibernate:
select
teacher0_.id as id1_1_0_,
teacher0_.t_name as t_name2_1_0_,
students1_.teacher_id as teacher_3_0_1_,
students1_.id as id1_0_1_,
students1_.id as id1_0_2_,
students1_.s_name as s_name2_0_2_,
students1_.teacher_id as teacher_3_0_2_
from
t_teacher teacher0_
left outer join
student students1_
on teacher0_.id=students1_.teacher_id
where
teacher0_.id=?
2
HQL检索方式
Hibernate的检索方式的概述
Hibernate检索数据的五种方式：
1.导航对象图检索方式。（根据已经加载的对象，导航到其他对象--如关联对象的查询。）
2.OID检索方式。（按照对象的OID来检索对象。前面讲的get,load就是这种）
3.HQL检索方式。（使用面向对象的HQL查询语言。）
4.QBC检索方式。（使用QBC(Qurey By Criteria) API来检索对象。用的不多）
5.本地SQL检索方式。（使用本地数据库的SQL查询语句。）
HQL检索方式
HQL（Hibernate Query Language）是面向对象的查询语言，它和SQL查询语言有些相似。在Hibernate提供的各种检索方式中，HQL是使用最广的一种检索方式。它具有以下功能：
在查询语句中设定各种查询条件。
支持投影查询，即仅检索出对象的部分属性。
支持分页查询。
支持分组查询，允许使用group by和having关键字。
提供内置聚集函数，如sum()、min()和max()。
能够调用用户定义的SQL函数。
支持子查询，即嵌套查询。
支持动态绑定参数，如sql语句的?占位符。
Session类的Qurey接口支持HQL检索方式，它提供了以上列出的各种查询功能。
注:Qurey接口支持方法链编程风格，它的set方法都返回自身实例，而不是返回void类型。方法链编程风格能使程序代码更加简洁。
示例代码：Teacher,Student中的双向多对一关联的例子中的代码为基础
//HQL
@Test
public void HqlTest() {
//写hql
/*String hql = "from Teacher";
Query<Teacher> query=session.createQuery(hql);
//如果hql有条件，使用？占位符，动态的参数绑定
List<Teacher> teachers = query.list();*/
//或可写成方法链方式
List<Teacher> teachers =session.createQuery("from Teacher").list();
System.out.println(Arrays.toString(teachers.toArray()));
}
QBC（Qurey By Criteria）
和QBC的子功能QBE(Qurey By Example)检索方式
criteria = session.createCriteria(User.class)
1.获取CriteriaBuilder对象
CriteriaBuilder build = session.getCriteriaBuilder();
2.获取CriteriaQuery
CriteriaQuery<Department> criteriaQuery=build.createQuery(Department.class);
3.指定根条件
Root<Department> root=criteriaQuery.from(Department.class);
crq.select(root);
crq.where(build.like(root.get("departmentName"),"%A%"));
4.执行查询
Query<Department> query = session.createQuery(criteriaQuery);
5.返回查询结果集
List<Department> lists =query.getResultList();
本地SQL检索方式
采用HQL检索方式时，Hibernate生成标准的SQL查询语句，使用于所有的数据库平台，因此这种检索方式是跨平台的。有的应用程序可能需要根据底层数据库的SQL方言，来生成一些特殊的查询语句。在这种需求情况下，Hibernate提供的原生SQL检索方式。
示例代码：
Query<Object[]> query = session.createNativeQuery("select t.* from teacher as t where t.name like :tname and t.id=:tid");
// 动态绑定参数
query.setParameter("tname", "zs").setParameter("tid", 1);
// 执行检索
List<Object[]> result = query.list();
for(Object[] objs:result) {
System.out.println(Arrays.toString(objs));
}
以上我们看到了五种检索方式的应用的概述
HQL基础知识
准备
1.把employees数据库的两个表，复制到hibernate5数据库中，然后通过手工修改dept_no为int数据类型，前提是要先删除所有的给约束和外键，我们只是利用一下员工中数据，再通自已定义Department,Employee来建立两者对应的双向多对一关联，在employees中将建立一个外键，对应departments中的主键关联。
2.建两个类，Deptemp.java,Employee.java形式多对一双向的关系，由多端(Employee)维护关系
Department.java—Department.hbm.xml
public class Department {
private int deptNo;
private String deptName;
private Set<Employee> employees; //多对一双向的，一个部门有多个员工
//get,set,toString()不显示关联对象信息，避免栈溢出，无参构造
}
------------------------------------------------------------------------------------------------------------------------
<hibernate-mapping package="cn.ybzy.hibernatedemo.model">
<class name="Department" table="departments">
<id name="deptNo" type="int">
<column name="dept_no" />
<generator class="native" />
</id>
<property name="deptName" type="string">
<column name="dept_name" />
</property>
<set name="employees" table="employees" inverse="true" lazy="true">
<key>
<column name="dept_no" />
</key>
<one-to-many class="Employee" />
</set>
</class>
</hibernate-mapping>
Employee.java ----Employee.hbm.xml
public class Employee {
private int empNo;
private Date birthDate;
private String firstName;
private String lastName;
private String gender;
private Date hireDate;
private Department department; //每个员工都员一个部门
//get,set,toString()不显示关联对象信息，避免栈溢出，无参构造
}
------------------------------------------------------------------------------------------------------------------------
<hibernate-mapping package="cn.ybzy.hibernatedemo.model">
<class name="Employee" table="employees">
<id name="empNo" type="int">
<column name="emp_no" />
<generator class="native" />
</id>
<property name="birthDate" type="java.util.Date">
<column name="birth_date" />
</property>
<property name="firstName" type="java.lang.String">
<column name="first_name" />
</property>
<property name="lastName" type="java.lang.String">
<column name="last_name" />
</property>
<property name="gender" type="java.lang.String">
<column name="gender" />
</property>
<property name="hireDate" type="java.util.Date">
<column name="hire_date" />
</property>
<many-to-one name="department" class="Department" >
<column name="dept_no" />
</many-to-one>
</class>
</hibernate-mapping>
hibernate.cfg.xml核心配置文件
<mapping resource="cn/ybzy/hibernatedemo/model/Employee.hbm.xml"/>
<mapping resource="cn/ybzy/hibernatedemo/model/Department.hbm.xml"/>
测试1：动态参数绑定，只查询大于5的编号的部门并且是包含 Q字母的部门
/*String hql="from Department d where d.deptNo>? and d.deptName like ?";
Query<Department> query=session.createQuery(hql);
List<Department> departments=query.setParameter(0,5).setParameter(1, "%Q%").list();
System.out.println(Arrays.toString(departments.toArray()));*/
//这里要0，1是占位符起始位置，可读性差，我们可用别名来代替，
String hql="from Department d where d.deptNo> :did and d.deptName like :dname";
Query<Department> query=session.createQuery(hql);
List<Department> departments=query.setParameter("did",5).setParameter("dname", "%Q%").list();
System.out.println(Arrays.toString(departments.toArray()));
------------------------------------------------------------------------------------------------------------------------------------
Hibernate:
select
department0_.dept_no as dept_no1_0_,
department0_.dept_name as dept_nam2_0_
from
departments department0_
where
department0_.dept_no>?
and (
department0_.dept_name like ?
)
[Department [deptNo=6, deptName=Quality Management]]
测试2： 查询1号部站下的所有员工，直接可用部门对象查，这在传统的sql语句中是不可能这样做的
String hql="from Employee e where e.department=?";
Department department=new Department();
department.setDeptNo(1);
System.out.println(Arrays.toString(session.createQuery(hql)
.setParameter(0, department)
.list().toArray()));
------------------------------------------------------------------------------------------------------------------------
Hibernate:
select
employee0_.emp_no as emp_no1_1_,
employee0_.birth_date as birth_da2_1_,
employee0_.first_name as first_na3_1_,
employee0_.last_name as last_nam4_1_,
employee0_.gender as gender5_1_,
employee0_.hire_date as hire_dat6_1_,
employee0_.dept_no as dept_no7_1_
from
employees employee0_
where
employee0_.dept_no=?
[Employee [empNo=10001, birthDate=1953-09-02 00:00:00.0, firstName=Georgi, lastName=Facello, gender=M, hireDate=1986-06-26 01:00:00.0], Employee [empNo=10002, birthDate=1964-06-02 00:00:00.0, firstName=Bezalel, lastName=Simmel, gender=F, hireDate=1985-11-21 00:00:00.0], Employee [empNo=10003, birthDate=1959-12-03 00:00:00.0, firstName=Parto, lastName=Bamford, gender=M, hireDate=1986-08-28 01:00:00.0], Employee [empNo=10004, birthDate=1954-05-01 00:00:00.0, firstName=Chirstian, lastName=Koblick, gender=M, hireDate=1986-12-01 00:00:00.0], Employee [empNo=10032, birthDate=1960-08-09 00:00:00.0, firstName=Jeong, lastName=Reistad, gender=F, hireDate=1990-06-20 01:00:00.0], Employee [empNo=10033, birthDate=1956-11-14 00:00:00.0, firstName=Arif, lastName=Merlo, gender=M, hireDate=1987-03-18 00:00:00.0],......