1. hibernate sql查询结果集怎么转换
在多表查询的时候使用hibernate的sql查询的时候,一般返回的是object[]数组,或者可以使用
session.createSQLQuery(sql).setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);
来转化为map来进行处理,可以通过以下方式将查询结果转化为实体类:
1,sql语句 String sql="select s.id as id,s.classname as classname from grade s,student st where s.id=st.classid"
利用以下语句
session.createSQLQuery(sql) .setResultTransformer(Transformers.aliasToBean(Grade.class))可以将sql中查询出来的字段转化为班级这个实体类,但是必须为每个字段指定别名,别名就是班级类里面的对应的属性,但必须注意，对每一个列都必须addScalar("列名"),如果不设置addScalar方法可能会报转型错误的异常.如果查询的结果里面包括多个表里面的字段,不能对应一个实体类去接受,就需要新建一个与查询结果对应的实体类,或者直接使用map结果集
2,sql语句 String sql="select {s.*} from grade s,student st where s.id=st.classid"
针对这样的全部字段查询的sql可以利用addEntity来转化为实体类
SQLQuery query=session.createSQLQuery(sql) ;
query.addEntity("s", Grade.class);
SQL查询语句，它带一个占位符，可以让Hibernate使用字段的别名.
查询返回的实体，和它的SQL表的别名.
addEntity()方法将SQL表的别名和实体类联系起来，并且确定查询结果集的形态。
这样就可以将班级这张表里面的所有字段的值赋值给班级这个实体类java培训机构排名,而且必须是所有的属性
3,sql语句 String sql="select {s.*},{st.*} from grade s,student st where s.id=st.classid"
SQLQuery query=session.createSQLQuery(sql) ;
query.addEntity("s", Grade.class);
query.addEntity("st", Student.class);
利用这样的查询得到的是一个object[]数组,object[0]就是班级实体类,object[1]就是学生实体类
可以用addScalar（String arg,Type type）方法定义要返回的字段类型，如
s.createSQLQuery(shuiQingHQL).addScalar("STCD",Hibernate.STRING).addScalar("STNM")
2. hibernate,sql生成问题，谢谢帮忙
怎么可能是后面多了.dbo呢，这是系统生成的，没有错吧
咋一看，就知道是 could not execute query 不能执行查询语句
String queryString = "from SysUser as model where model."
+ propertyName + "= ?";
return getHibernateTemplate().find(queryString, “admin”);
admin的双引号是在中文转入法下输入的吧。
3. hibernate的三种查询方式
1.1、SQL概述
HQL是Hibernate Query Language的缩写，提供更加丰富灵活、更为强大的查询能力；HQL接近SQL`语句查询语法。
完整的HQL语句形式如下：
select | update | delete … from … where … group by … having … order by … asc|desc
其中的update、delete为Hibernate3中所新添加的功能，可见HQL查询非常类似于标准SQL查询。HQL查询在整个Hibernate实体操作体系中占核心地位。
String hql = "HQL语句";
Query query = session.createQuery(hql);
List list = query.list(); //查询得到多个实体对象集合
Object result = query.uniqueResult(); //查询得到一个实体对象
int x = query.executeUpdate(); //执行update或delete语句，返回数据表受影响行数
1.2、实体查询
查询过程中表名使用类名，列名使用属性名，类名和属性名称区分大小写
String hql="from Users";//from 实体类类型名称
Query query = session.createQuery(hql);
List<Users> list = query.list();
for (Users user : list) {
System.out.println(user);
}
1.3、带where的查询
Query query = session.createQuery("from Users where uid=3");
Users user = (Users) query.uniqueResult();//uniqueResult 单一对象
System.out.println(user);
Query query = session.createQuery("from Users where uid>5");
List<Users> list = query.list();
for (Users user : list) {
System.out.println(user);
}
1.3、属性查询
查询部分属性
String hql="select u.uid,u.uname,u.upwd from Users u where u.uname='张三'";
Query query = session.createQuery(hql);
List<Object[]> list = query.list();
for (Object[] objects : list) {
System.out.println(Arrays.toString(objects));
}
String hql="select new Users(u.uname,u.upwd) from Users u where u.uname='张三'";
Query query = session.createQuery(hql);
List<Users> list = query.list();
for (Users user : list) {
System.out.println(user);
}
1.4、实体的更新和删除
从hibernate 3版本开始才支持
//更新
String hql="update Users set uname='王五',upwd='321' where uid=3";
int res = session.createQuery(hql).executeUpdate();
//删除
String hql="delete from Users where uid=3";
int res = session.createQuery(hql).executeUpdate();
/*
返回值结果：
正整数：表受影响的行数据
0： 语句正常执行，但没有行受影响
负整数：通常是-1，执行HQL语句是一条查询语句
*/
HQL语句不能做添加
1.5、分组与排序
排序
处理方式和SQL语句中的排序是一样的
String hql="from Users order by uid";
Query query = session.createQuery(hql);
List<Users> list = query.list();
for (Users user : list) {
System.out.println(user);
}
order by语句只能出现在语句的最后位置
分组
处理方式和SQL语句中分组查询相同
分组语句需要处理筛选，只能使用having语句，而不能使用where语句。
String hql = "select e.dept.deptno, count(e) from Emp e group by dept.deptno";
String hql = "select e.dept.deptno, count(e) from Emp e group by dept.deptno having count(e)>=5";
1.6、参数绑定
使用占位参数
String hql="from Users where uid=? or uname=?";
Query query = session.createQuery(hql);
//索引从0开始
query.setInteger(0, 3);//query.setParameter(0, 3);
query.setString(1, "张三");//query.setParameter(1, "张三");
List<Users> list = query.list();
for (Users user : list) {
System.out.println(user);
}
使用参数名称
String hql = "from Users where uid=:no1 or uid=:no2";
Query query = session.createQuery(hql);
query.setInteger("no1", 1);
query.setInteger("no2", 3);
//....
可以使用点位参数和名称参数混合使用
String hql = "from User where uid=? or uid=:no2";
Query query = session.createQuery(hql);
query.setInteger(0, 7788);
query.setInteger("no2", 7566);
//....
//使用点位参数和名称参数混合使用，所有点位参数必须放在前面，一旦有名称参数出现，其后将不能再出现占位参数
1.7、连接查询
--SQL语句：查询员工姓名、薪资、部门名称
SELECT ENAME,SAL,DNAME
FROM EMP e JOIN DEPT d ON e.DEPTNO=d.DEPTNO
SELECT ENAME,SAL,DNAME FROM EMP,DEPT WHERE EMP.DEPTNO=DEPT.DEPTNO
没有on语句
能被连接到查询中的必须是主查询对象的子属性
String hql="SELECT e.ename, e.sal, e.dept.dname FROM Emp e";
//HQL连接查询
String hql="SELECT e.ename, e.sal, d.dname FROM Emp e JOIN e.dept d";
String hql = "SELECT e FROM Emp e JOIN e.dept"; //JOIN将没有意义
String hql = "FROM Emp e JOIN e.dept";
Query query = session.createQuery(hql);
List<Object[]> list = query.list();
//List集合中的数组中会保存两个元素：
//0：主数据(Emp)
//1：从数据(Dept)
//查询编号为7788的员工信息，同时将对应的dept信息和manager信息查询并保存在对应的子属性中
String hql = "FROM Emp e JOIN FETCH e.dept d JOIN FETCH e.manager m WHERE e.empno=7788";
Query query = session.createQuery(hql);
Emp emp = (Emp) query.uniqueResult();
System.out.println(emp);
System.out.println(emp.getManager());
System.out.println(emp.getDept());
1.8、分页
String hql = "from Users";
Query query = session.createQuery(hql);
query.setFirstResult(0);
query.setMaxResults(2);
2、QBC查询
QBC（Query By Criteria）查询就是通过使用Hibernate提供的Query By Criteria API来查询对象，这种API封装了SQL语句的动态拼装，对查询提供了更加面向对象的功能接口。
QBC查询最重要的三个类：
Restrictions 条件限制
Projections 列设射
Order 排序
2.1、查询实现
Criteria criteria = session.createCriteria(Users.class);
//session.createCriteria("entity.Users");
//session.createCriteria(Users.class, "别名");
List<Dept> list = criteria.list();
//查询单行结果（如果结果有两行或更多，会报错）
Object uniqueResult = criteria.uniqueResult();
2.2、Projections 列投射
语法：
//查询uname属性
Criteria criteria = session.createCriteria(Users.class);
PropertyProjection property = Projections.property("name");
criteria.setProjection(property);
List<Object> result = criteria.list();
//查询uname, upwd属性
Criteria criteria = session.createCriteria(Users.class);
//1.创建投射列表
ProjectionList projectionList = Projections.projectionList();
//2.向投射列表中添加列投射
PropertyProjection property1 = Projections.property("uname");
PropertyProjection property2 = Projections.property("upwd");
projectionList.add(property1).add(property2);
//3.将投射列表设置到准则中
criteria.setProjection(projectionList);
List<Object> result = criteria.list();
返回值类型 方法名称 描述
PropertyProjection Projections.property 指定某属性
AggregateProjection Projections.avg 求平均值
CountProjection Projections.count 统计某属性的数量
CountProjection Projections.countDistinct 统计某属性不同值的数量
PropertyProjection Projections.groupProperty 指定某个属性为分组属性
AggregateProjection Projections.max 求最大值
AggregateProjection Projections.min 求最小值
ProjectionList Projections.projectionList 创建一个ProjectionList对象
Projection Projections.rowCount 查询结果集中的记录条数
AggregateProjection Projections.sum 求某属性的合计
2.3、Restrictions 条件限制
语法:
Criteria criteria = session.createCriteria(Users.class);
Criterion notNull = Restrictions.isNotNull("comm");
criteria.add(notNull); //添加一个条件（如果添加了多个条件，默认条件之间使用and连接）
List<Users> list = criteria.list();
返回值类型 方法名称 描述
SimpleExpression Restrictions.eq 等于（equal）
Criterion Restrictions.allEq 使用Map,Key/Valu进行多个等于的比对
SimpleExpression Restrictions.gt 大于（great than）
SimpleExpression Restrictions.ge 大于等于（great than or equal）
SimpleExpression Restrictions.lt 小于（less than）
SimpleExpression Restrictions.le 小于等于（less than or equal）
Criterion Restrictions.between 对应SQL的between
SimpleExpression Restrictions.like 对应SQL的like
Criterion Restrictions.in 对应SQL的in
LogicalExpression Restrictions.and and关系
LogicalExpression Restrictions.or or关系
Criterion Restrictions.isNull 为空
Criterion Restrictions.sqlRestriction SQL限定查询
Criterion Restrictions.not 取反
2.3、Order排序
语法：
Criteria criteria = session.createCriteria(Dept.class);
criteria.addOrder(Order.asc("name"))
.addOrder(Order.desc("loc"));
//SELECT * FROM DEPT ORDER BY name ASC, loc DESC
返回值类型 方法名称 描述
Order Order.asc(String propertyName) 升序
Order Order.desc(String propertyName) 降序
2.4、分页查询
Criteria criteria = session.createCriteria(Dept.class);
int pageNum = 2, pageSize = 5;
criteria.setFirstResult((pageNum-1)*pageSize); //查询起始行下标
criteria.setMaxResults(pageSize); //查询的最大行数
List list = criteria.list();
//setFirstResult方法和setMaxResults方法同样可以在SQLQuery及Query类型上使用
3、原生SQL查询
1、查询
String sql = "select uid,uname,upwd from _users";
List list = session.createSQLQuery(sql).list();
for(Object obj : list){
System.out.println(obj);
}
2、 addEntity()
String sql = "select uid,uname,upwd from _users";
// addEntity()可以告诉Hibernate你想要封装成对象的类型，然后自动为你封装
SQLQuery query = session.createSQLQuery(sql).addEntity(Users.class);
List<User> list = query.list();
for(Users user : list){
System.out.println(user.getUname());
}
3、 uniqueResult
String sql = "select uid,uname,upwd from _users where uid = 2";
SQLQuery query = session.createSQLQuery(sql).addEntity(Users.class);
Users user = (Users) query.uniqueResult();//返回单一对象
System.out.println(user.getUname());
USB Microphone https://www.soft-voice.com/
Wooden Speakers https://www.zeshuiplatform.com/
亚马逊测评 www.yisuping.cn
深圳网站建设www.sz886.com
4. 浅谈hql和sql的区别，描述特别需要注意的地方
1.hql与sql的区别
sql 面向数据库表查询
hql 面向对象查询
hql ： from 后面跟的 类名＋类对象 where 后 用 对象的属性做条件
sql： from 后面跟的是表名 where 后 用表中字段做条件
查询
在Hibernate中使用查询时，一般使用Hql查询语句。
HQL（Hibernate Query Language），即Hibernate的查询语言跟SQL非常相像。不过HQL与SQL的最根本的区别，就是它是面向对象的。
使用HQL时需要注意以下几点：
l 大小写敏感
因为HQL是面向对象的，而对象类的名称和属性都是大小写敏感的，所以HQL是大小写敏感的。
Eg.
HQL语句：from Cat as cat where cat.id > 1;与from Cat as cat where cat.ID > 1;是不一样的，这点与SQL不同。
l from子句
Eg. from Cat，该句返回Cat对象实例，开发人员也可以给其加上别名，eg. from Cat as cat，对于多表查询的情况，可参考如下：
from Cat as cat, Dog as dog
其它方面都与SQL类似，在此不再赘述。
接下来讲一个在Hibernate中查询的例子。
1.1简单查询
List list = session.createQuery("from User as user order by user.loginName").list();
1.2带单个参数的查询
List list = session.find("from User as user where user.loginName=?",
loginName,
Hibernate.STRING);
1.3多个参数的查询
Eg1. 此例采用“?”占位符的方式
String hql = "from User as user where user.loginName=? and user.orgId=? ";
Query query = session.createQuery(hql);
query.setParameter(1, 'amigo');
query.setParameter(2, new Long(1)) ;
List list = query .list();
Eg2. 此例采用“:paramName”的方式
String hql = "from User as user where user.loginName=:loginName and user.orgId=:orgId ";
Query query = session.createQuery(hql);
query.setParameter('loginName', 'amigo');
query.setParameter('orgId', new Long(1)) ;
List list = query .list();
1.4查询数量
int count = (Integer) session.createQuery("select count(*) from User").uniqueResult().intValue();
1.5限制查询起始值和数量的查询
这种一般是在记录需要分页的时候需要用到，例如，在如下的代码中，限制查询的开始记录的位置为50，最大查询条数为50。
String hql = "from User as user order by user.loginName";
int firstResult= 50;
int maxResults = 50;
Query query = session.createQuery(hql);
query = query.setFirstResult(firstResult);
query.setMaxResults(maxResults);
1.6子查询
在某些情况下，也需要用到子查询，例如在下面的例子中，User为用户对象，UserRole为用户与角色关联对象。如下HQL语句将没有分配角色的用户对象查找出来。
String hql = "from User user where user.loginName"
+ " not in(select ur.user.loginName from UserRole ur) ";
List list = (session.createQuery(hql)).list();
1.7原生SQL查询
对于某些复杂的查询语句，需要调用某种特定的数据库的特定函数才能解决，Hibernate虽然不推荐使用原生SQL语句来查询，因为这将破坏数据库的易移植性，但是Hibernate中也提供了使用原生SQL进行查询的方法，只需要获得连接即可。
Eg. 在下面的例子中，用到了Sql Server数据库中的原生sql语句，如下所示：
String timeUnit = "13";
String sql = "select count(*) count, CONVERT(VARCHAR(" + timeUnit +"), log.gen_datetime,121) timeUnit " + "from Log log";
SQLQuery query = session.createSQLQuery(sql)
.addScalar("count", Hibernate.INTEGER)
.addScalar("timeUnit", Hibernate.STRING);
List list = query.list();
2 新增
在数据库中新增记录在Hibernate中不需要使用insert命令，只需要构造新增的对象后，调用Session对象的save(…)方法即可。
2.1新增单个对象
新增单个对象的实例如下，该实例将在用户表中新增一条记录。
Session session = HibernateSessionFactory.getSession();
Transaction ts = null;
try {
ts = session.beginTransaction();
User user = new User();
user.setLoginName("amigo");
user.setFullName("阿蜜果");
……
session.save(user) ;
ts.commit();
} catch (Exception e) {
if (ts != null) {
ts.rollback();
}
} finally {
HibernateSessionFactory.closeSession();
}
2.2批量新增对象
对于批量新增对象的情况，需要在新增一部分对象后flush和clear一次，例如，没批量新增20个对象时手动的flush一次，假设在list为一个用户列表，里面包含很多User对象，那么要将实现这些对象的批量新增，可采用如下方法：
Session session = HibernateSessionFactory.getSession();
Transaction ts = null;
try {
ts = session.beginTransaction();
for (int i = 0; i < list.size(); i++) {
User user = (User) list.get(i);
session.save(user) ;
if (i % 20 == 0) {
session.flush();
session.clear();
}
}
ts.commit();
} catch (Exception e) {
if (ts != null) {
ts.rollback();
}
} finally {
HibernateSessionFactory.closeSession();
}
3 更新
在hibernate中，更新对象前不需要使用查询语句：update…，一般需要在取得需要更新的持久化对象后，执行Session对象的update(…)方法。例如：
Session session = HibernateSessionFactory.getSession();
Transaction ts = null;
try {
ts = session.beginTransaction();
//取得持久化对象
User user = session.get(User.class, "amigo");
//对需要修改的属性进行修改
user.setFullName("阿蜜果");
……
session.update(user) ;
ts.commit();
} catch (Exception e) {
if (ts != null) {
ts.rollback();
}
} finally {
HibernateSessionFactory.closeSession();
}
4 删除
4.1删除单个对象
一般在取得某对象后，开发人员可以调用Session对象的delete(…)方法删除该对象。
Eg. 下面的实例中取得loginName（主键）为“amigo”的User对象后，将它删除。
Session session = HibernateSessionFactory.getSession();
Transaction ts = null;
try {
ts = session.beginTransaction();
//取得持久化对象
User user = session.get(User.class, "amigo");
session.delete(user) ;
ts.commit();
} catch (Exception e) {
if (ts != null) {
ts.rollback();
}
} finally {
HibernateSessionFactory.closeSession();
}
4.2批量删除对象
对于批量删除对象的情况，开发人员可以在取得待删除的对象列表后，一个一个的将对象删除，对于每个对象的删除方法，见3.4.1小节。开发人员还可以hql语句来做批量删除。
Eg. 该实例通过delete语句来删除记录，除了loginName为“amigo”的对象为，其余都删除，代码如下所示：
Session session = HibernateSessionFactory.getSession();
Transaction ts = null;
try {
ts = session.beginTransaction();
String hql = "delete User as user where user.loginName != 'amigo'";
Query query = session.createQuery(hql);
int count = query.executeUpdate();
ts.commit();
System.out.println("delete count : " + count); //删除条数
} catch (Exception e) {
if (ts != null) {
ts.rollback();
}
} finally {
HibernateSessionFactory.closeSession();
}
5. 如何得到hibernate显示在控制台的hql或sql语句
不知道楼主的意思是不是把那些占位符换成具体的值，这样就可以直接复制SQL语句在数据库控制台粘贴直行了。
如果是这样的话。楼主有没有注意过直行hibernate时总是报的警告：
log4j:WARN Please initialize the log4j system properly.
使用这个log4j就可以显示相信信息。
我给你一个属性文件:log4j.properties把他放到和hibernate.cfg.xml相同目录下。修改属性文件中属性log4j.logger.org.hibernate.type=debug
这样，就可以显示详细数据了。
把以下内容保存命名log4j.properties
### direct log messages to stdout ###
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
### direct messages to file hibernate.log ###
#log4j.appender.file=org.apache.log4j.FileAppender
#log4j.appender.file.File=hibernate.log
#log4j.appender.file.layout=org.apache.log4j.PatternLayout
#log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
### set log levels - for more verbose logging change 'info' to 'error' ###
log4j.rootLogger=warn, stdout
#log4j.logger.org.hibernate=info
log4j.logger.org.hibernate=error
### log HQL query parser activity
#log4j.logger.org.hibernate.hql.ast.AST=error
### log just the SQL
#log4j.logger.org.hibernate.SQL=error
### log JDBC bind parameters ###
log4j.logger.org.hibernate.type=debug
#log4j.logger.org.hibernate.type=error
### log schema export/update ###
log4j.logger.org.hibernate.tool.hbm2ddl=error
### log HQL parse trees
#log4j.logger.org.hibernate.hql=error
### log cache activity ###
#log4j.logger.org.hibernate.cache=error
### log transaction activity
#log4j.logger.org.hibernate.transaction=error
### log JDBC resource acquisition
#log4j.logger.org.hibernate.jdbc=error
### enable the following line if you want to track down connection ###
### leakages when using ###
#log4j.logger.org.hibernate.connection.=trace
6. Hibernate4 HQL查询占位符的问题
0.0 h4换写法了吗..看你的代码感觉和h3变化好大....
h3的写法 给你参考一下吧.
public List<Department> FindById(Serializable id) {//按ID 查询
return getHibernateTemplate().find("from Department where deptid = ?",id);
}
7. hibernate中sql不等于的使用
1、sql中有两种方式表示不等于，一种是"<>"(不含引号)，另一种是"!="(不含引号)，用法是一样的。 2、那就是where a <> 100; 或者where a != 100; 结构化查询语言(Structured Query Language)简称SQL(发音：/ˈes kjuː ˈel/ "S-Q-L")，是一种特殊目的的编程语言，是一种数据库查询和程序设计语言，用于存取数据以及查询、更新和管理关系数据库系统；同时也是数据库脚本文件的扩展名。 结构化查询语言是高级的非过程化编程语言，允许用户在高层数据结构上工作。它不要求用户指定对数据的存放方法，也不需要用户了解具体的数据存放方式，所以具有完全不同底层结构的不同数据库系统, 可以使用相同的结构化查询语言作为数据输入与管理的接口。结构化查询语言语句可以嵌套，这使它具有极大的灵活性和强大的功能
8. 关于hibernate中占位符和mysql中:=的问题
我也遇到同样的情况，hiberate是支持这种写法的，你仔细看看你的sql语句是否写对了
9. Hibernate中的SQL写法。
我比较喜欢hibernate本身自带的HQL语言，增删改查语句基本不用自己写。
添加：
Admin admin=new Admin();
admin.set...();
session.save(admin);
删除：
session.delete(admin);
修改：
Admin admin=session.load(Admin.class,new Integer(i));
session.saveOrUpdate(admin);
查询：
Query query = session.createQuery("select OBJECT(o) from Admin o order by o.adminid");
亦可写成：
Query query = session.createQuery("from Admin");
注意：hibernate的业务逻辑操作必须放在事务中，代码如下：
Transaction tr = session.beginTransaction();
try {
****增删改查语句***
// 提交事务
tr.commit();
} catch (Exception e) {
// 回滚事务
tr.rollback();
} finally {
}
还有，hibernate内的语句不是SQL，而是HQL，但它支持SQL，又它特定的写法；表名不是数据库的名字，而是映射后的实体类（表）的名字；而且，是直接对数据库进行操作，也就hibernate的事务一提交，数据库内的信息就做了相应的修改；最后，hibernate不是个软件，而是一个插件，通俗的说法是别人写好的“包”，导入项目后，根据“包”的规范去做快速开发。
10. Hibernate4 升级到Hibernate5 中 sql查询注意事项
在 Hibernate4 中，利用原生SQL语句查询时，
1、可使用Session.createSQLQuery(sql)建立Qurey（org.hibernate.Query），
2、可使用Query.setParameter(int index, Object obj)，对sql语句中的参数根据位置进行参数值动态绑定;
升级到 Hibernate5 后
1、org.hibernate.Query被标记为@Deprecated
2、Session().createSQLQuery(sql)返回类型为org.hibernate.query.Query;
3、并且Session().createSQLQuery也已经被标记为@Deprecated；
4、可使用Session().createNativeQuery(sql)代替createSQLQuery。
5、createNativeQuery返回的Query, 不可 通过setParameter(int index, Object obj) 根据位置 进行参数值动态绑定； 只可以 通过setParameter(String paramname, Object obj) 按参数名称绑定 。
6、createNativeQuery（sql）中的sql语句中的 查询占位符
只可使用 命名参数 方式进行编写。
上问错误例子中，将导致如下错误：