Hibernate-hql語法總結.

悠悠隱於市發表於2011-02-25

 hibernate------hql總結

1. 查詢整個對映物件所有欄位
Java程式碼：
  1. //直接from查詢出來的是一個對映物件，即：查詢整個對映物件所有欄位      
  2.         String hql = "from Users";      
  3.         Query query = session.createQuery(hql);      
  4.               
  5.         List<Users> users = query.list();      
  6.         for(Users user : users){      
  7.             System.out.println(user.getName() + " : " + user.getPasswd() + " : " + user.getId());      
  8.         }      
  9.      
  10.  輸出結果為：      
  11. name1 : password1 : 1     
  12. name2 : password2 : 2     
  13. name3 : password3 : 3     
//直接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


2.查詢單個欄位 
Java程式碼 複製程式碼
  1. //查詢單個欄位      
  2.         String hql = " select name from Users";      
  3.         Query query = session.createQuery(hql);      
  4.               
  5.         List<String> list = query.list();      
  6.         for(String str : list){      
  7.             System.out.println(str);      
  8.         }      
  9. 輸出結果為：      
  10. name1      
  11. name2      
  12. name3    
//查詢單個欄位   
        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


3.查詢其中幾個欄位
 
Java程式碼 複製程式碼
  1. //查詢其中幾個欄位      
  2.         String hql = " select name,passwd from Users";      
  3.         Query query = session.createQuery(hql);      
  4.         //預設查詢出來的list裡存放的是一個Object陣列      
  5.         List<Object[]> list = query.list();      
  6.         for(Object[] object : list){      
  7.             String name = (String)object[0];      
  8.             String passwd = (String)object[1];      
  9.                   
  10.             System.out.println(name + " : " + passwd);      
  11.         }      
  12. 輸出結果為：      
  13. name1 : password1      
  14. name2 : password2      
  15. name3 : password3    
//查詢其中幾個欄位   
        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


4.修改預設查詢結果(query.list())不以Object[]陣列形式返回，以List形式返回
引用
//查詢其中幾個欄位,新增new list(),注意list裡的l是小寫的。也不需要匯入包，這樣通過query.list()出來的list裡存放的不再是預設的Object陣列了，而是List集合了  
        String hql = " select new list(name,passwd) from Users";  
        Query query = session.createQuery(hql);  
        //預設查詢出來的list裡存放的是一個Object陣列，但是在這裡list裡存放的不再是預設的Object陣列了，而是List集合了  
        List<List> list = query.list();  
        for(List user : list){  
            String name = (String)user.get(0);  
            String passwd = (String)user.get(1);  
              
            System.out.println(name + " : " + passwd);  
        }  
        /** 
        輸出結果為： 
         name1 : password1 
        name2 : password2 
        name3 : password3 
         */ 

5.修改預設查詢結果(query.list())不以Object[]陣列形式返回，以Map形式返回
Java程式碼 複製程式碼
  1. //查詢其中幾個欄位,新增new map(),注意map裡的m是小寫的。也不需要匯入包，這樣通過query.list()出來的list裡存放的不再是預設的Object陣列了，而是map集合了      
  2.         String hql = " select new map(name,passwd) from Users";      
  3.         Query query = session.createQuery(hql);      
  4.         //預設查詢出來的list裡存放的是一個Object陣列，但是在這裡list裡存放的不再是預設的Object陣列了，而是Map集合了      
  5.         List<Map> list = query.list();      
  6.         for(Map user : list){      
  7.             //一條記錄裡所有的欄位值都是map裡的一個元素,key是字串0,1,2,3....，value是欄位值      
  8.             //如果將hql改為：String hql = " select new map(name as username,passwd as password) from Users";,那麼key將不是字串0,1,2...了，而是"username","password"了      
  9.             String name = (String)user.get("0");//get("0");是get(key),注意:0,1,2...是字串，而不是整形      
  10.             String passwd = (String)user.get("1");      
  11.                   
  12.             System.out.println(name + " : " + passwd);      
  13.         }      
  14.         /**    
  15.         輸出結果為：    
  16.          name1 : password1    
  17.         name2 : password2    
  18.         name3 : password3    
  19.          */    
//查詢其中幾個欄位,新增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  
         */

6.修改預設查詢結果(query.list())不以Object[]陣列形式返回，以Set形式返回,但是因為Set裡是不允許有重複的元素，所以:username和password的值不能相同。只需將hql改為：String hql = " select new set(name,passwd) from Users";

7.修改預設查詢結果(query.list())不以Object[]陣列形式返回，以自定義型別返回

自定義類：
 
Java程式碼 複製程式碼
  1. package com.domain;      
  2.      
  3. public class MyUser {      
  4.      
  5.     private String username;      
  6.     private String password;      
  7. //因為：String hql = " select new  com.domain.MyUser(name,passwd) from Users";所以必須要有接受2個引數的建構函式      
  8.     public MyUser(String username,String password){      
  9.         this.username = username;      
  10.         this.password = password;      
  11.     }      
  12.           
  13.     public String getUsername() {      
  14.         return username;      
  15.     }      
  16.     public void setUsername(String username) {      
  17.         this.username = username;      
  18.     }      
  19.     public String getPassword() {      
  20.         return password;      
  21.     }      
  22.     public void setPassword(String password) {      
  23.         this.password = password;      
  24.     }      
  25.           
  26.           
  27. }    
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;   
    }   
       
       
}


 
Java程式碼 複製程式碼
  1. //通過query.list()出來的list裡存放的不再是預設的Object陣列了,而是自定義的類MyUser,必須加包名，String hql = "from Users";中的Users類也是必須加包名的，但是因為再Users.hbm.xml裡<hibernate-mapping auto-import="true"> auto-import預設值為true（所以auto-import屬性也可以不寫）,自動匯入了      
  2.         String hql = " select new  com.domain.MyUser(name,passwd) from Users";      
  3.         Query query = session.createQuery(hql);      
  4.         //預設查詢出來的list裡存放的是一個Object陣列，但是在這裡list裡存放的不再是預設的Object陣列了，而是MyUser物件了      
  5.         List<MyUser> myUsers = query.list();      
  6.         for(MyUser myUser : myUsers){      
  7.             String name = myUser.getUsername();      
  8.             String passwd = myUser.getPassword();      
  9.             System.out.println(name + " : " + passwd);      
  10.         }      
  11.         /**    
  12.         輸出結果為：    
  13.         name1 : password1    
  14.         name2 : password2    
  15.         name3 : password3    
  16.          */    
//通過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  
         */


8：條件查詢
Java程式碼 複製程式碼
  1. //條件查詢，引數索引值從0開始，索引位置。通過setString,setParameter設定引數      
  2.         String hql = "from Users where name=? and passwd=?";      
  3.         Query query = session.createQuery(hql);      
  4.         //第1種方式      
  5. //      query.setString(0, "name1");      
  6. //      query.setString(1, "password1");      
  7.         //第2種方式      
  8.         query.setParameter(0, "name1",Hibernate.STRING);      
  9.         query.setParameter(1, "password1",Hibernate.STRING);      
  10.         List<Users> list = query.list();      
  11.         for(Users users : list){      
  12.             System.out.println(users.getId());      
  13.         }     
//條件查詢，引數索引值從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());   
        }
         
Java程式碼 複製程式碼
  1. //條件查詢，自定義索引名(引數名):username,:password.通過setString,setParameter設定引數      
  2.         String hql = "from Users where name=:username and passwd=:password";      
  3.         Query query = session.createQuery(hql);      
  4.         //第1種方式      
  5. //      query.setString("username", "name1");      
  6. //      query.setString("password", "password1");      
  7.         //第2種方式,第3個引數確定型別      
  8.         query.setParameter("username", "name1",Hibernate.STRING);      
  9.         query.setParameter("password", "password1",Hibernate.STRING);      
  10.         List<Users> list = query.list();      
  11.         for(Users users : list){      
  12.             System.out.println(users.getId());      
  13.         }    
//條件查詢，自定義索引名(引數名):username,:password.通過setString,setParameter設定引數   
        String hql = "from Users where name=:username and passwd=:password";   
        Query query = session.createQuery(hql);   
        //第1種方式   
//      query.setString("username", "name1");   
//      query.setString("password", "password1");   
        //第2種方式,第3個引數確定型別   
        query.setParameter("username", "name1",Hibernate.STRING);   
        query.setParameter("password", "password1",Hibernate.STRING);   
        List<Users> list = query.list();   
        for(Users users : list){   
            System.out.println(users.getId());   
        }


Java程式碼 複製程式碼
  1. //條件查詢,通過setProperties設定引數      
  2.         String hql = "from Users where name=:username and passwd=:password";      
  3.         Query query = session.createQuery(hql);      
  4.         //MyUser類的2個屬性必須和:username和:password對應      
  5.         MyUser myUser = new MyUser("name1","password1");      
  6.         query.setProperties(myUser);      
  7.         List<Users> list = query.list();      
  8.         for(Users users : list){      
  9.             System.out.println(users.getId());      
  10.         }    

博文地址:http://kuangbaoxu.iteye.com/blog/193076 .

相關文章