`
sungang_1120
  • 浏览: 321629 次
  • 性别: Icon_minigender_1
  • 来自: 成都
社区版块
存档分类

Hibernate 的HQL,QBC 查询语言

hibernatejava 
阅读更多

1.HQL:(Hibernate Query Language) 是面向对象的查询语言 

1.实体查询 

public void testQueryAllDept(){  
String hql="from Employee";  
       //hql="from com.sh.Entity";  
Query query=session.createQuery(hql);  
  
List<Employee> list= query.list();  
  
//...  
}
 



2.有条件的 实体查询 

    public void testQueryAllDept(){  
    String hql="from Deptas model where mode.deptName='人事部' ";  
           //hql="from com.sh.Entity";  
    Query query=session.createQuery(hql);  
      
    List<Employee> list= query.list();  
      
    //...  
    }  
    public void testQueryAllDept(){  
    String hql="from Deptas model where mode.deptName like '%部%' ";  
           //hql="from com.sh.Entity";  
    Query query=session.createQuery(hql);  
      
    List<Employee> list= query.list();  
      
    //...  
    }  
      
     public void testQueryDeptByGt(){  
      
     String hql="from Dept model where model.createDate> '2012-03-10'";  
     Query query=session.createQuery(hql);  
     List<Employee> list= query.list();  
     }
 




3.HQL 中的各种运算符 

运算符类型 HQL运算符 含义
比较运算 = 等于
  <> 不等于
  > 大于
  >= 大于等于
  <= 小于等于
  < 小于
  is null 为空
  is not null 不为空
范围运算 in 等于列表中的某一值
  not in 不等于列表中的任意一个值
  between  p1 and p2 大于等于值1  且 小于等于值2
  not between p1 and p2 小于值1 或者 大于 值2
字符串模式匹配 like 字符串模式匹配
逻辑运算 and 与
  or 或
  not 非



3.更新 删除 

    public void testModifyDate(){  
            Transaction tr=session.beginTransaction();  
            Dept detp=(Dept)session.get(Detp.class,new Integer(6));  
            detp.seteCreateDate("2000-03-10");  
            tr.commit();  
              
        }  
      
    // delete  删除  
    public void testDelDeptByHql(){  
            Transaction tr=session.beginTransaction();  
            String hql="delete Dept as model where model.deptId=6";  
            Query query=session.createQuery(hql);  
            query.executeUpdate();  
            tr.commit();  
        }
 


4.属性查询 

    public void testQueryDeptName(){  
        String hql="select model.deptName from Dept as model";  
        Query query=session.createQuery(hql);  
        List<String> deptNameList=query.list();  
        //...  
    }  
           public void testQueryDeptName(){  
        String hql="select model.deptName,model.createDate from Dept as model";  
        Query query=session.createQuery(hql);  
        List<Object[]> prsList=query.list();  
                   for(){  
                   }                 
        //...  
    }  
          
       //采用对象进行 保存 查询的字段(要添加 对应字段的构造方法)  
        public void testQueryDeptName(){  
        String hql="select new Dapt(model.deptName,model.createDate) from Dept as model";  
        Query query=session.createQuery(hql);  
        List<Dept> deptList=query.list();  
                   for(Dept d:deptList){  
                      
                      d.setDeptName("test");  
                      session.saveOrUpdate(dept);  
                   }                 
        //...  
    }  
      
          
       //如果采用对象 保存上面查询出来的对象  如果对其进行更新的操作 是不会成功的  
      
    public void testSaveDept(){  
        Transction  tr=session.beginTransactino();  
        String hql="select new Dept(model.deptName,model.createDate) from Dept as model";  
        Query query=session.createQuery();  
        List<Dept> deptList=query.list();  
        for(Dept dept:deptList){  
            System.out.println(dept.deptName);  
            dept.setDetpName("test");  
            session.saveOrUpdate(dept);  
        }  
        tr.commit();  
          // 最后 根本就没有更新 而是 在数据库中 插入 新的记录  
    }
 



5.使用函数 

    public void testQuyeryFunction(){  
            String hql="select count(*),min(model.createDate) from Dept as model";  
            Query query=session.createQuery(hql);  
            List<Object[]> paramsList=query.list();  
            for(){  
                  
            }  
            //...  
        }
 



6.分组 与 排序 

    //排序  
    public void testQueryOrderBy(){  
            String hql="from Dept as mode order by   model.createDate,model.deptName desc";  
            Query query=session.createQuery();  
            List<Dept> deptList=query.list();  
            for(){}  
            //  
              
        }  
      
    //分组 并且 使用  having 筛选  
    public void testQueryGroupBy(){  
            String hql="select count(model),model.deptName from Dept as model group by model.deptName having count(model)>1";  
            Query query=session.createQuery();  
            List<Object[]> list=query.list();  
            //...  
        }
 



7.查询单个对象 

    public void testQueryUn(){  
            String hql="select model.deptName from Dept as model where model.deptId=2";  
            Query query=session.createQuery(hql);  
            query.setMaxResults(1);  
            String deptName=(String)query.uniqueResult();  
            System.out.println(deptNamae);  
        }
 



8.绑定参数 
释义:Hibernate中也采用了preparedStatement作为底层数据库的的访问方式,与之对应的SQL语句 可以重用preparedStatement对象, 首先会预编译,然后缓存起来,提高性能. 

1.使用 ":"加参数名 绑定参数 

    public void  testQueryByParamsName(){  
               //使用  ":参数名" 来传递参数  
        String hql="from Dept as model where   
    odel.deptName=:deptName and model.createDate=:createDate";  
      
        Query query=session.createQuery(hql);  
        query.setString("deptName","test");  
        query.setString("ceateDate","2000-02-10");  
        List<Dept> deptList=query.list();  
        for(){}  
          
        //...  
          
    }

 
2.使用 "?" 按照位置来绑定参数 

    public void testQueryByParamsID(){  
        String hql="from Dept as model where model.deptName=? and model.createDate=?";  
        Query query=session.createQuery(hql);  
        query.setString(0,"test");  
        query.setString(1,"2000-02-02");  
        List<Dept> list=query.list();  
        for(){}  
        //..  
    }
 


3.采用setEntity() 将参数和一个持久化对象进行绑定 

    public void testQueryByDept(){  
            Dept dept=(Dept)Session.get(Dept.clas,new Integer(2));  
            String hql="select Employee  as model where model.dept=?"  
            Query query=session.createQuery(hql);  
            query.setEntity(0,dept);  
            List<Employee> empList=query.list();  
            for(){}  
            //..  
              
              
        }
 


4.setParameter() 用于绑定任意类型的参数 

    public void testQueryBySetParams(){  
            String hql="from Dept as model where model.deptName=?";  
            Query query=session.createQuery(hql);  
            query.setParameter(0,"test");  
            List<Dept> deptList=query.list();  
            for(){}  
            //..  
        }
 



5.setProperties() 将一个参数名 于一个对象的属性值绑定 

    public void testQueryBySetPro(){  
            Dept deptNew=new  Dept();  
            deptNew.setDeptName("test");  
              
            String hql="from Dept as model where model.deptName=:deptName";  
            Query query=session.createQuery();  
            query.setProperties(deptNew);  
            List<Dept> deptList=query.list();  
            for(){  
                  
            }  
            //..  
              
        }
 



10. 联合查询 
inner join 

    public void testQueryInnerJoin(){  
            String hql="from Dept as model inner join model1.employees as model2";  
            Query query=session.createQuery(hql);  
            List<Object[]> objList=query.list();  
            for(Object[] obj:objList){  
                Dept dept=(Dept)obj[0];  
                Employee emp=(Employee)obj[1];  
                System.out.println("xxxx");  
            }  
        }
 


left join 

    public void testQueryLeftJoin(){  
            String hql="from Dept as model left join model1.employees as model2";  
            Query query=session.createQuery(hql);  
            List<Object[]> objList=query.list();  
            for(Object[] obj:objList){  
                Dept dept=(Dept)obj[0];  
                Employee emp=(Employee)obj[1]; //有可能为空 所以需要判断  
                if(mep!=null){  
                    System.out.println("xxxx");  
                }else{  
                    System.out.println(null);  
                }  
                System.out.println(dept.getDeptName());  
            }  
        }
 


right join 

    public void testQueryRightJoin(){  
        String hql="from Dept as model right join model1.employees as model2";  
        Query query=session.createQuery(hql);  
        List<Object[]> objList=query.list();  
        for(Object[] obj:objList){  
            Dept dept=(Dept)obj[0];  
            Employee emp=(Employee)obj[1]; //有可能为空 所以需要判断  
            if(dept!=null){  
                System.out.println(dept.getDeptName());  
            }else{  
                System.out.println(null);  
            }  
            System.out.println("dd"+emp.getEmployeeName());  
        }  
    }
 


11.子查询 

    public void testQueryChild(){  
        String hql="from Dept as model where (select count(*) from model.employee) >2";  
        Query query=session.createQuery(hql);  
        List<Dept> objList=query.list();  
        for(){}  
        //..  
    }
 



12 Criteria 查询 
释义:通过面向对象的设计将数据查询条件封装在一个对象 

    //无条件  
    public void testQueryDept(){  
            Criteria criteria=session.createCriteria(Dept.class);  
            List<Dept> deptList=criteria.list();  
            for(){}  
            //..  
        }  
      
    //添加条件  
    public void testQueryDeptByName(){  
            Criteria criteria=session.createCriteria(Dept.class);  
            criteria.add(Expression.eq("deptName", "人事部"));  
            List<Dept> deptList=criteria.list();  
            for(){}  
            //..  
        }

 

SQL语法查询机制 

方法 描述
Expression.eq 对应sql中的field =value
Expression.gt 对应sql中的field>value
Expression.ge 对应sql中的field>=value
Expression.lt 对应sql中的field<value
Expression.le 对应sql中的field<=value
Expression.between 对应sql中的between
Expression.like 对应 like
Expression.in 对应 in
Expression.eqProperty 用于比较两个属性之间的值,对应的Sql条件中field=field
Expression.gtProperty 用于比较两个属性之间的值,对Sqlfiled>field
Expression.geProperty 用于比较两个属性之间的值,对应sql field>=field
Expression.ltProperty 用于比较两个属性之间的值,对应field<field
Expression.leProperty 用于比较 两个属性之间的值,对应field<=field




Hibernate3中采用Restrictions类代替Expression 

public void  testQueryDeptByNameRe(){  
        Criteria  criteria=session.createCriteria(Dept.class);  
        criteria.add(Restrictions.eq("deptName", "人事部"));  
        List<Dept> deptList=criteria.list();  
        for(){}  
        //..  
          
    }

 

 



Criteria中限定返回的行数 

    public void testQueryDept(){  
            Criteria criteria=session.createCriteria(Dept.class);  
            criteria.setFirstResult(2);  
            criteria.setMaxResults(2);  
            List<Dept> deptList=criteria.list();  
            for(){}  
            //..  
        }
 



Criteria排序 

        public void testQueryDept(){  
                Criteria criteria=session.createCriteria(Dept.class);  
                criteria.addOrder(Order.asc("createDate"));  
                List<Dept> deptList=criteria.list();  
                for(){}  
                //..  
            }

 转载：http://www.cnblogs.com/jifeng/archive/2013/03/03/2941181.html

分享到：
| Hibernate 缓存机制
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Hibernate实例开发 HQL 与 QBC 查询

    首先，HQL是Hibernate专门设计的一种面向对象的查询语言，它的语法类似于SQL，但更注重对象而非表。例如，如果我们有一个`User`实体，我们可以使用HQL来获取所有用户： ```java Session session = sessionFactory....

    Hibernate-HQL-QBC-QBE

    2. HQL（Hibernate Query Language）：HQL是Hibernate提供的面向对象的查询语言，类似于SQL，但它是针对对象而不是表格进行操作的。HQL允许开发者以类和对象的方式编写查询，支持复杂的查询结构，如连接、子查询、...

    HQL与QBC的查询条件.doc

    HQL是一种面向对象的查询语言，类似于SQL，但它是针对对象和类的，而不是针对表和列。HQL允许开发者以类和对象的方式书写查询，从而避免了直接处理底层数据库的复杂性。以下是一些常见的HQL运算符： 1. **比较运算*...

    精通hibernate HQL语言

    HQL，全称Hibernate Query Language，是Hibernate框架提供的一种面向对象的查询语言，它的语法结构与SQL相似，但主要针对对象和实体进行操作，而不是直接操作数据库表。HQL是Hibernate官方推荐的检索数据的主要方式...

    Java_Hibernate QBC条件查询对比

    相对而言，HQL是一种面向对象的查询语言，类似于SQL，但更加面向对象。开发者可以直接在HQL语句中指定类名、属性名，进行复杂的查询操作，包括但不限于分页、排序、联接等。HQL的优势在于其强大的功能，能够处理复杂...

    Hibernate的查询方式

    HQL是Hibernate特有的查询语言，它采用面向对象的语法结构，使开发者能够在不脱离对象模型的情况下进行数据库操作。与传统的SQL相比，HQL更侧重于对象的属性和关联，而非数据库的表和字段，这使得代码更易于理解和...

    QBC查询的别名方的

    - **HQL与HBM的关系**：HQL是一种面向对象的查询语言，用于查询和操作Hibernate管理的对象。它依赖于HBM映射文件定义的对象模型，因此，正确配置HBM文件对于HQL的正常使用至关重要。 #### 2. Projection在查询中的...

    Hibernate查询语言.doc

    本文主要探讨Hibernate中的查询语言，包括面向对象的查询语言HQL，QueryBy Criteria (QBC)，Query By Example (QBE)，以及原生SQL的使用。 1. **大小写敏感性** HQL查询语句对Java类和属性名称的大小写敏感，而...

    4.Hibernate-04查询以及优化策略1

    HQL（Hibernate Query Language，Hibernate 查询语言）是 Hibernate 提供的一种查询语言，它可以用于查询数据库中的数据。HQL 查询可以分为两种：一种是基于对象的查询，另一种是基于 SQL 的查询。 1.1 基于对象的 ...

    hibernate映射和查询

    这些查询语言提供了面向对象的方式来检索数据，比传统的 SQL 更加灵活和强大。 1. **HQL**：类似于 SQL，但它是面向对象的。例如，以下 HQL 查询语句用于获取所有学生： ```java Session session = ...

    hibernate查询详解

    Hibernate Query Language（HQL）是一种面向对象的查询语言，类似于SQL但更专注于对象而不是表格。HQL查询分为HQL查询和HQL命名查询。 A. HQL查询：通过编写HQL语句来执行查询，例如： ```java String hql=...

    NHibernate HQL 条件查询

    而HQL则是NHibernate提供的一种查询语言，它允许开发人员使用类似于SQL的语法来查询数据库，同时保持了面向对象的特性。 ### NHibernate HQL条件查询详解 #### QBC（Query By Criteria）与HQL对比 在NHibernate中...

    hibernate 数据库操作方法

    HQL是Hibernate特有的面向对象的查询语言，其语法类似于SQL，但操作的是对象和集合。它可以更自然地映射到Java对象。例如，查找所有年龄大于30岁的用户： ```java String hql = "FROM User WHERE age &gt; :age"; ...

    Hibernate教程21_HIbernate查询

    HQL是Hibernate提供的面向对象的查询语言，类似于SQL但更接近于面向对象编程的概念。HQL允许开发者以类和对象的方式书写查询，而不是以表格和列。例如，以下是一个简单的HQL查询示例： ```java Session session = ...

    Hibernate学习笔记(3)

    ### Hibernate中的HQL与QBC查询详解 #### 一、引言 Hibernate作为一个强大的对象关系映射（ORM）框架，极大地简化了Java开发者与数据库交互的过程。本文将深入探讨Hibernate中两种常用的查询语言——HQL...

    hibernate查询方法

    HQL是Hibernate提供的面向对象的查询语言，类似于SQL，但更加面向对象。它的优点在于可以与Java对象直接交互，避免了SQL与对象之间的转换。例如，以下是一个简单的HQL查询示例： ```java Query query = session....

    hibernate查询

    HQL 查询是基于 SQL 的一种面向对象的查询语言，它可以实现复杂的查询操作，同时保持代码的简洁性和可读性。 **特点：** - **面向对象**：使用 HQL 可以以面向对象的方式编写 SQL 语句。 - **语法简洁**：与原生 ...

    Hibernate的查询 测试的架子

    HQL是面向对象的查询语言，类似于SQL但与特定的数据库无关，它允许开发者用类和属性的名字进行查询。QBC则通过构建Criteria对象来执行查询，这种方式更为灵活，可以动态构建查询条件。Criteria API是JPA2.0引入的新...

    Hql详解[文].pdf

    Hibernate Query Language（Hql）是Hibernate框架中用于操作对象-关系映射（ORM）的一种语言，它模仿了EJBQL的设计，旨在提供一种跨数据库的查询方式。Hql与SQL有诸多相似之处，但其核心是面向对象而非数据库表格，...

    hibernate的查询方式介绍和hibernate的批处理和连接池配置hibernate

    HQL 是 Hibernate 自带的一种类似于 SQL 的查询语言，它可以用来执行各种数据库操作。HQL 支持面向对象的语法，使得查询更加直观。 - **标准 HQL** - **读取数据** - `select` 子句用于指定要获取的数据字段。 -...

Magicbox
Global site tag (gtag.js) - Google Analytics