本文目录
- hibernate hql语句查询报错org.hibernate.hql.ast.QuerySyntaxException:
- hibernate hql 如何写 not in 删除
- hibernate怎么写 select Nvl(max(cast(a as number)),0)+1 as BM from b
- hibernate的setParameter()方法有什么用
- 为什么我hibernate session.createQuery（hql）不能加select * ..只能是 from .. 别人的可是是完整的hql语
- hibernate中one to one关联更新报hql语法错误，cause by “join cross“错误
- 怎样使用泛型实现Hibernate查询返回对象
hibernate hql语句查询报错org.hibernate.hql.ast.QuerySyntaxException:
sb.append("select "); sb.append("new map(s.title,count(distinct(o.id)) onum ,count(distinct(i.vuser.userId)) unum )"); sb.append("from "); sb.append("Subject s left join Option o left join Item i ");定义中，有关联，不需要写on
hibernate hql 如何写 not in 删除
hibernate的删除是对对象的删除,因此你可以先通过查询语句把你要查询的not in那个对象查出来,然后再把这个对象删除.查询是可以自己定义hql的.
hibernate怎么写 select Nvl(max(cast(a as number)),0)+1 as BM from b
不知道你的cast(a as number)是什么意思，但是写成select Nvl(max(to_number(a)),0)+1 as BM from b就可以了，其中a是可以转换成number类型的字段，验证过在hibernate里是可以用的。
hibernate的setParameter()方法有什么用
setParameter() 方法设置一个样式表参数。
说明：这个方法为指定的样式表参数指定一个值。
语法：：setParameter(namespaceURI,localName,value)
为什么我hibernate session.createQuery（hql）不能加select * ..只能是 from .. 别人的可是是完整的hql语
hql语句是这样的啊，这是hql语句的语法，如果要是完整的，那就是使用createSQLQuery
hibernate中one to one关联更新报hql语法错误，cause by “join cross“错误
你的语法错误 update 表明 set order_state=? .... where order_id=? cross join 这两个是关键字 冒号如果有set 和get的字段对应，不用复值，get 方法会自动复值 如果你是2张表修改一个字段，最好用sql处理 HQL 对单表处理很好用，多表查询让你很郁闷的 ，希望对你有帮助
怎样使用泛型实现Hibernate查询返回对象
我可以给你demo，你可以参考
接口你可以自己写
package com.shopping.b2b.dao.impl;
import java.io.Serializable;
import java.lang.reflect.Field;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import javax.annotation.Resource;
import javax.persistence.Table;
import org.apache.log4j.Logger;
import org.hibernate.Hibernate;
import org.hibernate.Query;
import org.hibernate.SQLQuery;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.transform.Transformers;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
import com.shopping.b2b.dao.ISuperDao;
@Repository("superDao")
public class SuperDaoImpl implements ISuperDao{
@Resource
private SessionFactory hibernateSessionFactory;
public SessionFactory getHibernateSessionFactory() {
return hibernateSessionFactory;
}
public void setHibernateSessionFactory(SessionFactory hibernateSessionFactory) {
this.hibernateSessionFactory = hibernateSessionFactory;
}
private Logger logger = Logger.getLogger(this.getClass());
private Session getCurrentSession() {
return this.hibernateSessionFactory.getCurrentSession();
}
@Override
public 《T》 T get(Class《T》 clazz, Serializable id) {
return (T)this.getCurrentSession().get(clazz, id);
}
@Override
public 《T》 T getSql(String sql, Map《String, Object》 params, Class《T》 po) {
SQLQuery q = this.getCurrentSession().createSQLQuery(sql);
/*
* say:
* 从数据库查出来的数据类型给po，如果要自定义，那么需要扩展addScalar
* 默认情况：数据库字段类型是什么类型，返回的po也是什么类型。移植性不好
* 可扩展
*/
if(po != null){
q.setResultTransformer(Transformers.aliasToBean(po));
}else{
q.setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);
}
if(params != null && !params.isEmpty()){
for (String k : params.keySet()) {
Object v = params.get(k);
if(v != null){
if(v instanceof Object){
q.setParameterList(k, (Object)v);
}else if(v instanceof Collection《?》){
q.setParameterList(k, (Collection《?》)v);
}else{
q.setParameter(k, v);
};
}
}
}
List《T》 list = q.list();
return list == null || list.isEmpty() ? null:list.get(0);
}
@Override
public Serializable save(Object entity) {
return this.getCurrentSession().save(entity);
}
@Override
public boolean update(Object entity) {
boolean result = false;
try {
this.getCurrentSession().update(entity);
result = true;
} catch (Exception e) {
result = false;
}
return result;
}
@Override
public boolean updateSql(String sql,Map《String, Object》 params) {
SQLQuery q = this.getCurrentSession().createSQLQuery(sql);
if(params != null && !params.isEmpty()){
for (String k : params.keySet()) {
Object v = params.get(k);
if(v != null){
if(v instanceof Object){
q.setParameterList(k, (Object)v);
}else if(v instanceof Collection《?》){
q.setParameterList(k, (Collection《?》)v);
}else{
q.setParameter(k, v);
};
}
}
}
return q.executeUpdate() == 0 ? false :true;
}
@Override
public boolean delete(Object entity) {
boolean result = false;
try {
this.getCurrentSession().delete(entity);
result = true;
} catch (Exception e) {
result = false;
}
return result;
}
@Override
public 《T》 boolean deleteSql(Class《T》 clazz,Serializable id) {
boolean result = false;
try {
Table table = (Table)clazz.getAnnotation(Table.class);
if(table != null){
String tableName = table.name();
this.getCurrentSession()
.createSQLQuery("delete from :tableName where id = :id")
.setParameter("tableName", tableName)
.setParameter("id", id)
.executeUpdate();
}
result = true;
} catch (Exception e) {
result = false;
}
return result;
}
@Override
public 《T》 List《T》 queryList(String sql, Map《String, Object》 params, Class《T》 po) {
SQLQuery q = this.getCurrentSession().createSQLQuery(sql);
/*
* say:
* 从数据库查出来的数据类型给po，如果要自定义，那么需要扩展addScalar
* 默认情况：数据库字段类型是什么类型，返回的po也是什么类型。移植性不好
* 可扩展
*/
if(po != null){
q.setResultTransformer(Transformers.aliasToBean(po));
}else{
q.setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);
}
if(params != null && !params.isEmpty()){
for (String k : params.keySet()) {
Object v = params.get(k);
if(v != null){
if(v instanceof Object){
q.setParameterList(k, (Object)v);
}else if(v instanceof Collection《?》){
q.setParameterList(k, (Collection《?》)v);
}else{
q.setParameter(k, v);
}
}
}
}
List《T》 list = q.list();
return list == null || list.isEmpty() ? null:list;
}
@Override
public 《T》 List《T》 queryList(String sql, Map《String, Object》 params, int firstResult, int maxResults, Class《T》 po) {
SQLQuery query = this.getCurrentSession().createSQLQuery(sql);
/*
* say:
* 从数据库查出来的数据类型给po，如果要自定义数据类型，那么需要扩展addScalar
* 默认情况：数据库字段类型是什么类型，返回的po也是什么类型。移植性不好
* 可扩展
*/
if(po != null){
query.setResultTransformer(Transformers.aliasToBean(po)).setFirstResult(firstResult).setMaxResults(maxResults);
}else{
query.setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP).setFirstResult(firstResult).setMaxResults(maxResults);
}
//this.addScalarsToString(query, po).setFirstResult(firstResult).setMaxResults(maxResults);//test
if(params != null && !params.isEmpty()){
for (String k : params.keySet()) {
Object v = params.get(k);
if(v != null){
if(v instanceof Object){
query.setParameterList(k, (Object)v);
}else if(v instanceof Collection《?》){
query.setParameterList(k, (Collection《?》)v);
}else{
query.setParameter(k, v);
}
}
}
}
List《T》 list = query.list();
return list == null || list.isEmpty() ? null:list;
}
@Override
public 《T》 Serializable queryCount(String sql, Map《String, Object》 params) {
Query query = this.getCurrentSession().createSQLQuery(sql);
if(params != null && !params.isEmpty()){
for (String k : params.keySet()) {
Object v = params.get(k);
if(v != null){
if(v instanceof Object){
query.setParameterList(k, (Object)v);
}else if(v instanceof Collection《?》){
query.setParameterList(k, (Collection《?》)v);
}else{
query.setParameter(k, v);
}
}
}
}
return Integer.parseInt(query.uniqueResult().toString());
}
/**
* 扩展
* 默认将class的属性类型转换为hibernate所对应的的类型《br/》
* 如果严格的话请使用Transformers.aliasToBean(T.class)《br/》
* 对应表如下：
* 未实现
* @param query
* @param cls
* @return
*/
private 《T》 Query addScalarsToCustom(SQLQuery query,Class《T》 cls){
Field fields = cls.getDeclaredFields();
for(Field item:fields){
////System.out.println(item.getName() + ":" + item.getGenericType());
//该接口需要判断，返回的属性类型，然后转换为hibernate语法
//System.out.println(item.getName() + ":" + item.getGenericType());
//该接口需要判断，返回的属性类型，然后转换为hibernate语法
if("class java.math.BigInteger".equals(item.getGenericType().toString())){
//System.out.println(cls.getName() +":"+item.getName() + " ||==int");
}else if("class java.lang.String".equals(item.getGenericType().toString())){
//System.out.println(cls.getName() +":"+item.getName() + " ||==String");
}else if("class java.math.BigDecimal".equals(item.getGenericType().toString())){
//System.out.println(cls.getName() +":"+item.getName() + " ||==String");
}else{
//System.out.println(cls.getName() +":"+item.getName() + " ||==未匹配类型");
}
}
return null;
}
}
