Hibernate之HQL总结

hibernate运行过程：

Hibernate作用
    1、hibernate是java应用和关系数据库之间的桥梁，她负责java对象和关系数据库之间的映射。
    2、hibernate内部封装了通过JDBC访问数据库的操作，向上层应用提供了面向对象的数据访问API。
Hibernate API简介
    1.提供访问数据库操作（session，transaction，query）
    2.配置hibernate接口(configuration)
    3.回调接口（Interceptor，Lifecycle，Vaildatable）
    4.用于扩展的功能接口（UserType，ComposititeUserType,IdentifierGenerator）
Query和Criteria接口
    都是查询接口，query实例包装了HQL（HQL: Hibernate查询语言）查询语句，hql是面向对象的，她引用类名及类的属性名
    而不是表名和字段名。Criteria接口完全封装了基于字符串形式的查询语句，比query'接口更面向对象
    ，她擅长执行动态查询。session接口的find方法也居右数据查询功能，但她只是执行一些简单的hql
    查询语句的快捷方式，远没有query接口功能强大。

//直接from查询出来的是一个映射对象，即：查询整个映射对象所有字段   
        String hql = "from Users";   
        Query query = session.createQuery(hql);   
           
        List<Users> users = query.list();   
        for(Users user : users){   
            System.out.println(user.getName() + " : " + user.getPasswd() + " : " + user.getId());   
        }   
  
 输出结果为：   
name1 : password1 : 1  
name2 : password2 : 2  
name3 : password3 : 3  

　　

//查询单个字段   
        String hql = " select name from Users";   
        Query query = session.createQuery(hql);   
           
        List<String> list = query.list();   
        for(String str : list){   
            System.out.println(str);   
        }   
输出结果为：   
name1   
name2   
name3  

//查询其中几个字段   
        String hql = " select name,passwd from Users";   
        Query query = session.createQuery(hql);   
        //默认查询出来的list里存放的是一个Object数组   
        List<Object[]> list = query.list();   
        for(Object[] object : list){   
            String name = (String)object[0];   
            String passwd = (String)object[1];   
               
            System.out.println(name + " : " + passwd);   
        }   
输出结果为：   
name1 : password1   
name2 : password2   
name3 : password3  

//查询其中几个字段,添加new map(),注意map里的m是小写的。也不需要导入包，这样通过query.list()出来的list里存放的不再是默认的Object数组了，而是map集合了   
        String hql = " select new map(name,passwd) from Users";   
        Query query = session.createQuery(hql);   
        //默认查询出来的list里存放的是一个Object数组，但是在这里list里存放的不再是默认的Object数组了，而是Map集合了   
        List<Map> list = query.list();   
        for(Map user : list){   
            //一条记录里所有的字段值都是map里的一个元素,key是字符串0,1,2,3....，value是字段值   
            //如果将hql改为：String hql = " select new map(name as username,passwd as password) from Users";,那么key将不是字符串0,1,2...了，而是"username","password"了   
            String name = (String)user.get("0");//get("0");是get(key),注意:0,1,2...是字符串，而不是整形   
            String passwd = (String)user.get("1");   
               
            System.out.println(name + " : " + passwd);   
        }   
        /**  
        输出结果为：  
         name1 : password1  
        name2 : password2  
        name3 : password3  
         */  

package com.domain;   
  
public class MyUser {   
  
    private String username;   
    private String password;   
//因为：String hql = " select new  com.domain.MyUser(name,passwd) from Users";所以必须要有接受2个参数的构造函数   
    public MyUser(String username,String password){   
        this.username = username;   
        this.password = password;   
    }   
       
    public String getUsername() {   
        return username;   
    }   
    public void setUsername(String username) {   
        this.username = username;   
    }   
    public String getPassword() {   
        return password;   
    }   
    public void setPassword(String password) {   
        this.password = password;   
    }   
       
       
}  

//通过query.list()出来的list里存放的不再是默认的Object数组了,而是自定义的类MyUser,必须加包名，String hql = "from Users";中的Users类也是必须加包名的，但是因为再Users.hbm.xml里<hibernate-mapping auto-import="true"> auto-import默认值为true（所以auto-import属性也可以不写）,自动导入了   
        String hql = " select new  com.domain.MyUser(name,passwd) from Users";   
        Query query = session.createQuery(hql);   
        //默认查询出来的list里存放的是一个Object数组，但是在这里list里存放的不再是默认的Object数组了，而是MyUser对象了   
        List<MyUser> myUsers = query.list();   
        for(MyUser myUser : myUsers){   
            String name = myUser.getUsername();   
            String passwd = myUser.getPassword();   
            System.out.println(name + " : " + passwd);   
        }   
        /**  
        输出结果为：  
        name1 : password1  
        name2 : password2  
        name3 : password3  
         */  

//条件查询，参数索引值从0开始，索引位置。通过setString,setParameter设置参数   
        String hql = "from Users where name=? and passwd=?";   
        Query query = session.createQuery(hql);   
        //第1种方式   
//      query.setString(0, "name1");   
//      query.setString(1, "password1");   
        //第2种方式   
        query.setParameter(0, "name1",Hibernate.STRING);   
        query.setParameter(1, "password1",Hibernate.STRING);   
        List<Users> list = query.list();   
        for(Users users : list){   
            System.out.println(users.getId());   
        }   

//条件查询,通过setProperties设置参数      
        String hql = "from Users where name=:username and passwd=:password";      
        Query query = session.createQuery(hql);      
        //MyUser类的2个属性必须和:username和:password对应      
        MyUser myUser = new MyUser("name1","password1");      
        query.setProperties(myUser);      
        List<Users> list = query.list();      
        for(Users users : list){      
            System.out.println(users.getId());      
        }  

在where子句中允许使用的表达式包括 大多数你可以在SQL使用的表达式种类:

数学运算符+, -, *, /

二进制比较运算符=, >=, <=, <>, !=, like

逻辑运算符and, or, not

in, not in, between, is null, is not null, is empty, is not empty, member of and not member of

"简单的" case, case ... when ... then ... else ... end,和 "搜索" case, case when ... then ... else ... end

字符串连接符...||... or concat(...,...)

current_date(), current_time(), current_timestamp()

second(...), minute(...), hour(...), day(...), month(...), year(...),

EJB-QL 3.0定义的任何函数或操作：substring(), trim(), lower(), upper(), length(), locate(), abs(), sqrt(), bit_length()

coalesce() 和 nullif()

cast(... as ...), 其第二个参数是某Hibernate类型的名字，以及extract(... from ...)，只要ANSI cast() 和 extract() 被底层数据库支持

任何数据库支持的SQL标量函数，比如sign(), trunc(), rtrim(), sin()

JDBC参数传入 ?

命名参数:name, :start_date, :x1

SQL 直接常量 'foo', 69, '1970-01-01 10:00:01.0'

Java public static final 类型的常量 eg.Color.TABBY

 //查询编号为”S0002”的提供商提供的所有商品所涉及的类别

public void qryCategoriesBySupply(){
        Session session=this.getSession();
        List<Category>list=session.createQuery("select p.category from Product p where p.suppers.no=?")
        .setString(0, "S9002")
        .list();
        for(Category c:list){
            System.out.println(c.getName());
        }
        session.close();
    }

 //查询可以提供某种商品的供应商信息（使用elements处理）

 //查询名称为”TCL SHE8533”的商品的每个提供商的编号、名称(部分属性查询)

 public void qryNumName(){
    //select p.suppers.no,p.suppers.name from Product p where p.name='kodako'
    //select s.no,s.name from Supper s where s.products.name='kodako'
    Session session=this.getSession();
    List list=session
        .createQuery("select p.suppers.no,p.suppers.name from Product p where p.name='kodako'")
        .list();
    for(Object obj:list){
        Object[] object=(Object[])obj;
        System.out.println(object[0]+":"+object[1]);
    }
    session.close();
 }

 //查询可以提供某种商品的供应商信息（使用elements处理）

public void qrySupplyByElements(){
    Session session=this.getSession();
    Product product=(Product)session.get(Product.class, "0002");
    
    List<Supper> list=session
        .createQuery("from Supper s where :product in elements(s.products)")
        .setEntity("product", product)
        .list();
        
    for(Supper s:list){
        System.out.println(s.getName());
    }
    session.close();
}

//使用QBE查询，价格为2680,名称为”富士 S6500” 的商品

public void qryProByQBE(){
    Product product=new Product();
    product.setPrice(2680f);
    product.setName("富士 S6500");
    
    Session session=this.getSession();
    List<Product> list=session
        .createCriteria(Product.class)
        .add(Example.create(product))
        .list();
        
    for(Product p:list){
        System.out.println(p.getName()+":"+p.getPrice());
    }
    session.close();
}

 

转载地址：http://blog.csdn.net/xinyu0100/article/details/5385989