Hibernate 查詢

Kunaly發表於2018-03-07

技術分析之Hibernate框架的查詢方式

1. 唯一標識OID的檢索方式
    * session.get(物件.class,OID)
2. 物件的導航的方式

3. HQL的檢索方式
    * Hibernate Query Language  -- Hibernate的查詢語言

4. QBC的檢索方式
    * Query By Criteria -- 條件查詢

5. SQL檢索方式（瞭解）
    * 本地的SQL檢索

技術分析之HQL的查詢方式概述

1. HQL的介紹
    * HQL(Hibernate Query Language) 是物件導向的查詢語言, 它和 SQL 查詢語言有些相似
    * 在 Hibernate 提供的各種檢索方式中, HQL 是使用最廣的一種檢索方式

2. HQL與SQL的關係
    * HQL 查詢語句是物件導向的,Hibernate負責解析HQL查詢語句, 然後根據物件-關係對映檔案中的對映資訊, 把 HQL 查詢語句翻譯成相應的 SQL 語句. 
    * HQL 查詢語句中的主體是域模型中的類及類的屬性
    * SQL 查詢語句是與關聯式資料庫繫結在一起的. SQL查詢語句中的主體是資料庫表及表的欄位

技術分析之HQL的查詢演示

1. HQL基本的查詢格式
    * 支援方法鏈的程式設計，即直接呼叫list()方法
    * 簡單的程式碼如下
        * session.createQuery("from Customer").list();

2. 使用別名的方式
    * 可以使用別名的方式
        * session.createQuery("from Customer c").list();
        * session.createQuery("select c from Customer c").list();

3. 排序查詢
    * 排序查詢和SQL語句中的排序的語法是一樣的
        * 升序
            * session.createQuery("from Customer order by cust_id").list();

        * 降序
            * session.createQuery("from Customer order by cust_id desc").list();

4. 分頁查詢
    * Hibernate框架提供了分頁的方法，我們們可以呼叫方法來完成分頁
    * 兩個方法如下
        * setFirstResult(a)     -- 從哪條記錄開始，如果查詢是從第一條開啟，值是0
        * setMaxResults(b)      -- 每頁查詢的記錄條數

    * 演示程式碼如下
        * List<LinkMan> list = session.createQuery("from LinkMan").setFirstResult(0).setMaxResults().list();

5. 帶條件的查詢
    * setParameter("?號的位置，預設從0開始","引數的值"); 不用考慮引數的具體型別
    * 按位置繫結引數的條件查詢（指定下標值，預設從0開始）
    * 按名稱繫結引數的條件查詢（HQL語句中的 ? 號換成 :名稱 的方式）
    * 例如程式碼如下
        Query query = session.createQuery("from Linkman where lkm_name like ? order by lkm_id desc");
        query.setFirstResult(0).setMaxResults(3);
        query.setParameter(0, "%熊%");
        List<Linkman> list = query.list();
        for (Linkman linkman : list) {
            System.out.println(linkman);
        }

HQL的投影查詢

1. 投影查詢就是想查詢某一欄位的值或者某幾個欄位的值
2. 投影查詢的案例
    * 如果查詢多個欄位，例如下面這種方式
        List<Object[]> list = session.createQuery("select c.cust_name,c.cust_level from Customer c").list();
        for (Object[] objects : list) {
            System.out.println(Arrays.toString(objects));
        }

    * 如果查詢兩個欄位，也可以把這兩個欄位封裝到物件中
        * 先在持久化類中提供對應欄位的構造方法
        * 使用下面這種HQL語句的方式
            List<Customer> list = session.createQuery("select new Customer(c.cust_name,c.cust_level) from Customer c").list();
            for (Customer customer : list) {
                System.out.println(customer);
            }

技術分析之聚合函式查詢

1. 獲取總的記錄數
    Session session = HibernateUtils.getCurrentSession();
    Transaction tr = session.beginTransaction();
    List<Number> list = session.createQuery("select count(c) from Customer c").list();
    Long count = list.get(0).longValue();
    System.out.println(count);
    tr.commit();

2. 獲取某一列資料的和
    Session session = HibernateUtils.getCurrentSession();
    Transaction tr = session.beginTransaction();
    List<Number> list = session.createQuery("select sum(c.cust_id) from Customer c").list();
    Long count = list.get(0).longValue();
    System.out.println(count);
    tr.commit();

package com.kunaly.test;


import java.util.Arrays;
import java.util.List;

import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.Test;

import com.kunaly.domain.Customer;
import com.kunaly.domain.Linkman;
import com.kunaly.utils.HibernateUtils;

/**
 * 演示HQL的基本查詢
 * @author Administrator
 *
 */

public class Demo07 {

	/**
	 * 基本的演示
	 */
	@Test
	public void run1(){
		Session session = HibernateUtils.getSession();
		Transaction tr = session.beginTransaction();
		//建立HQL 的查詢介面
		Query query = session.createQuery("from Customer");
		//呼叫list()方法查詢
		List<Customer> list = query.list();
		
		for(Customer customer : list){
			System.out.println(customer);
		}
		
		tr.commit();
	}
	
	/**
	 * 支援方法鏈的程式設計風格
	 */
	@Test
	public void run2(){
		Session session = HibernateUtils.getSession();
		Transaction tr = session.beginTransaction();
		// 建立HQL的查詢的介面
		List<Customer> list = session.createQuery("from Customer").list();
		for (Customer customer : list) {
			System.out.println(customer);
		}
		tr.commit();
	}
	
	/**
	 * 是有別名的方式
	 * select * from cst_cutomer c
	 * select * from Customer 	語句錯誤的
	 */
	@Test
	public void run3(){
		Session session = HibernateUtils.getSession();
		Transaction tr = session.beginTransaction();
		// 建立HQL的查詢的介面
		List<Customer> list = session.createQuery("select c from Customer c").list();
		for (Customer customer : list) {
			System.out.println(customer);
		}
		tr.commit();
	}
	
	/**
	 * 排序查詢	
	 * SQL：order by 欄位 asc/desc;
	 * HQL：關鍵字是一樣的，都是有order by 屬性
	 */
	@Test
	public void run4(){
		Session session = HibernateUtils.getSession();
		Transaction tr = session.beginTransaction();
		// 查詢聯絡人
		List<Linkman> list = session.createQuery("from Linkman l order by l.lkm_id desc").list();
		for (Linkman linkman : list) {
			System.out.println(linkman);
		}
		tr.commit();
	}
	
	
	
	/**
	 * HQL分頁查詢的兩個方法
	 * 	* setFirstResult(a)		-- 從哪條記錄開始，如果查詢是從第一條開啟，值是0
		* setMaxResults(b)		-- 每頁查詢的記錄條數
	 */
	@Test
	public void run5(){
		Session session = HibernateUtils.getSession();
		Transaction tr = session.beginTransaction();
		// 查詢聯絡人
		Query query = session.createQuery("from Linkman l");
		
		// 分頁查詢，呼叫方法，查詢第一頁的資料 1-3條
		/*query.setFirstResult(0);
		query.setMaxResults(3);*/
		
		// 查詢第二頁的資料 query.setFirstResult(3);	(當前頁-1)*pageSize=3
		query.setFirstResult(3);
		query.setMaxResults(3);
		
		List<Linkman> list = query.list();
		for (Linkman linkman : list) {
			System.out.println(linkman);
		}
		tr.commit();
	}
	
	
	/**
	 * 按條件進行查詢
	 */
	@Test
	public void run6(){
		Session session = HibernateUtils.getSession();
		Transaction tr = session.beginTransaction();
		// 查詢聯絡人
		Query query = session.createQuery("from Linkman l where l.lkm_id > ? and l.lkm_gender = ?");
		// 傳入
		// query.setString(0, "男");
		// 傳入值
		// query.setString("gender", "女");
		// query.setLong(0, 2L);
		
		// 通用的方法，就不用再判斷具體的型別
		query.setParameter(0, 3L);
		query.setParameter(1, "女");
		
		List<Linkman> list = query.list();
		for (Linkman linkman : list) {
			System.out.println(linkman);
		}
		tr.commit();
	}
	
	

	/**
	 * 投影查詢：只查詢幾個欄位，不是所有的欄位
	 */
	@Test
	public void run7(){
		Session session = HibernateUtils.getSession();
		Transaction tr = session.beginTransaction();
		// 查詢聯絡人
		Query query = session.createQuery("select lkm_name,lkm_gender from Linkman");
		List<Object[]> list = query.list();
		for (Object[] objects : list) {
			System.out.println(Arrays.toString(objects));
		}
		tr.commit();
	}
	
	
	/**
	 * 投影查詢：只查詢幾個欄位，不是所有的欄位
	 * 第一步：需要在JavaBean類提供對應的構造方法
	 * 第二步：HQL語句的發生變化
	 */
	@Test
	public void run8(){
		Session session = HibernateUtils.getSession();
		Transaction tr = session.beginTransaction();
		// 查詢聯絡人
		Query query = session.createQuery("select new Linkman(lkm_name,lkm_gender) from Linkman");
		List<Linkman> list = query.list();
		for (Linkman linkman : list) {
			System.out.println(linkman);
		}
		tr.commit();
	}
	
	
	/**
	 * 聚合函式：count() sum() avg() max() min()
	 */
	@Test
	public void run9(){
		Session session = HibernateUtils.getSession();
		Transaction tr = session.beginTransaction();
		// 查詢的所有的聯絡人的數量
		List<Number> list = session.createQuery("select count(*) from Linkman").list();
		// 通過下標值取值
		Long count = list.get(0).longValue();
		System.out.println("數量："+count);
		tr.commit();
	}
	
	
	/**
	 * 聚合函式
	 */
	@Test
	public void run10(){
		Session session = HibernateUtils.getSession();
		Transaction tr = session.beginTransaction();
		// 查詢的所有的聯絡人的數量
		List<Number> list = session.createQuery("select count(l) from Linkman l").list();
		// 通過下標值取值
		Long count = list.get(0).longValue();
		System.out.println("數量："+count);
		tr.commit();
	}
	
	/**
	 * 聚合函式：求數量
	 */
	@Test
	public void run11(){
		Session session = HibernateUtils.getSession();
		Transaction tr = session.beginTransaction();
		// 查詢的所有的聯絡人的數量
		List<Number> list = session.createQuery("select sum(lkm_id) from Linkman l").list();
		// 通過下標值取值
		Long count = list.get(0).longValue();
		System.out.println("數量："+count);
		tr.commit();
	}
	
}

技術分析之QBC檢索方式

0. QBC：Query By Criteria  按條件進行查詢

1. 簡單查詢，使用的是Criteria介面
    List<Customer> list = session.createCriteria(Customer.class).list();
    for (Customer customer : list) {
        System.out.println(customer);
    }

2. 排序查詢
    * 需要使用addOrder()的方法來設定引數，引數使用org.hibernate.criterion.Order物件
    * 具體程式碼如下：
        Session session = HibernateUtils.getCurrentSession();
        Transaction tr = session.beginTransaction();
        Criteria criteria = session.createCriteria(Linkman.class);
        // 設定排序
        criteria.addOrder(Order.desc("lkm_id"));
        List<Linkman> list = criteria.list();
        for (Linkman linkman : list) {
            System.out.println(linkman);
        }
        tr.commit();

3. 分頁查詢
    * QBC的分頁查詢也是使用兩個方法
        * setFirstResult();
        * setMaxResults();

    * 程式碼如下;
        Session session = HibernateUtils.getCurrentSession();
        Transaction tr = session.beginTransaction();
        Criteria criteria = session.createCriteria(Linkman.class);
        // 設定排序
        criteria.addOrder(Order.desc("lkm_id"));
        criteria.setFirstResult(0);
        criteria.setMaxResults(3);
        List<Linkman> list = criteria.list();
        for (Linkman linkman : list) {
            System.out.println(linkman);
        }
        tr.commit();

4. 條件查詢（Criterion是查詢條件的介面，Restrictions類是Hibernate框架提供的工具類，使用該工具類來設定查詢條件）
    * 條件查詢使用Criteria介面的add方法，用來傳入條件。
    * 使用Restrictions的新增條件的方法，來新增條件，例如：
        * Restrictions.eq           -- 相等
        * Restrictions.gt           -- 大於號
        * Restrictions.ge           -- 大於等於
        * Restrictions.lt           -- 小於
        * Restrictions.le           -- 小於等於
        * Restrictions.between      -- 在之間
        * Restrictions.like         -- 模糊查詢
        * Restrictions.in           -- 範圍
        * Restrictions.and          -- 並且
        * Restrictions.or           -- 或者

    * 測試程式碼如下
        Session session = HibernateUtils.getCurrentSession();
        Transaction tr = session.beginTransaction();
        Criteria criteria = session.createCriteria(Linkman.class);
        // 設定排序
        criteria.addOrder(Order.desc("lkm_id"));
        // 設定查詢條件
        criteria.add(Restrictions.or(Restrictions.eq("lkm_gender", "男"), Restrictions.gt("lkm_id", 3L)));
        List<Linkman> list = criteria.list();
        for (Linkman linkman : list) {
            System.out.println(linkman);
        }
        tr.commit();

5. 聚合函式查詢（Projection的聚合函式的介面，而Projections是Hibernate提供的工具類，使用該工具類設定聚合函式查詢）
    * 使用QBC的聚合函式查詢，需要使用criteria.setProjection()方法
    * 具體的程式碼如下
        Session session = HibernateUtils.getCurrentSession();
        Transaction tr = session.beginTransaction();
        Criteria criteria = session.createCriteria(Linkman.class);
        criteria.setProjection(Projections.rowCount());
        List<Number> list = criteria.list();
        Long count = list.get(0).longValue();
        System.out.println(count);
        tr.commit();

技術分析之離線條件查詢

1. 離線條件查詢使用的是DetachedCriteria介面進行查詢，離線條件查詢物件在建立的時候，不需要使用Session物件，只是在查詢的時候使用Session物件即可。
2. 建立離線條件查詢物件
    * DetachedCriteria criteria = DetachedCriteria.forClass(Linkman.class);

3. 具體的程式碼如下
    Session session = HibernateUtils.getCurrentSession();
    Transaction tr = session.beginTransaction();

    DetachedCriteria criteria = DetachedCriteria.forClass(Linkman.class);
    // 設定查詢條件
    criteria.add(Restrictions.eq("lkm_gender", "男"));
    // 查詢資料
    List<Linkman> list = criteria.getExecutableCriteria(session).list();
    for (Linkman linkman : list) {
        System.out.println(linkman);
    }
    tr.commit();

package com.kunaly.test;


import java.util.ArrayList;
import java.util.List;

import org.hibernate.Criteria;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Projections;
import org.hibernate.criterion.Restrictions;
import org.junit.Test;

import com.kunaly.domain.Customer;
import com.kunaly.domain.Linkman;
import com.kunaly.utils.HibernateUtils;

/**
 * QBC的基本入門查詢
 * @author Administrator
 *
 */

public class Demo08 {

	/**
	 * QBC的基本入門查詢
	 */
	@Test
	public void run1(){
    	Session session = HibernateUtils.getSession();
	    Transaction tr = session.beginTransaction();
	    //建立QBC查詢介面
	    Criteria criteria = session.createCriteria(Customer.class);
	    List<Customer> list = criteria.list();
	    for(Customer customer : list){
	    	System.out.println(customer);
	    }
	    tr.commit();
	}
	
	/**
	 * QBC的基本入門查詢
	 * 排序查詢，呼叫的方法
	 */
	@Test
	public void run2(){
    	Session session = HibernateUtils.getSession();
	    Transaction tr = session.beginTransaction();
	    //建立QBC查詢介面
	    Criteria criteria = session.createCriteria(Linkman.class);
	    //呼叫排序的方法：addOrder();
	    criteria.addOrder(Order.desc("lkm_id"));
	    List<Linkman> list = criteria.list();
	    for(Linkman linkman : list){
	    	System.out.println(linkman.getLkm_name());
	    }
	    tr.commit();
	}
	
	
	/**
	 * QBC分頁的方法和HQL分頁的方式一樣的
	 */
	@Test
	public void run3(){
		Session session = HibernateUtils.getSession();
		Transaction tr = session.beginTransaction();
		// 建立QBC查詢介面
		Criteria criteria = session.createCriteria(Linkman.class);
		// 呼叫排序的方法，addOrder()
		criteria.addOrder(Order.desc("lkm_id"));
		
		// 設定分頁的方法
		criteria.setFirstResult(0);
		criteria.setMaxResults(3);
		
		List<Linkman> list = criteria.list();
		for (Linkman linkman : list) {
			System.out.println(linkman);
		}
		tr.commit();
	}
	
	
	/**
	 * QBC的條件查詢
	 */
	@Test
	public void run4(){
		Session session = HibernateUtils.getSession();
		Transaction tr = session.beginTransaction();
		// 建立QBC查詢介面
		Criteria criteria = session.createCriteria(Linkman.class);
		
		// 使用方法新增條件  and
		// criteria.add(Restrictions.eq("lkm_gender", "男"));
		// criteria.add(Restrictions.ge("lkm_id", 3L));
		// criteria.add(Restrictions.between("lkm_id", 2L, 5L));
		
		List<Linkman> list = criteria.list();
		for (Linkman linkman : list) {
			System.out.println(linkman);
		}
		tr.commit();
	}
	
	
	
	/**
	 * in查詢
	 */
	@Test
	public void run5(){
		Session session = HibernateUtils.getSession();
		Transaction tr = session.beginTransaction();
		// 建立QBC查詢介面
		Criteria criteria = session.createCriteria(Linkman.class);
		
		// SQL：select * from cst_linkman where lkm_id in (1,2,7);
		List<Long> params = new ArrayList<Long>();
		params.add(1L);
		params.add(2L);
		params.add(7L);
		
		// 使用in 方法查詢
		criteria.add(Restrictions.in("lkm_id", params));
		
		List<Linkman> list = criteria.list();
		for (Linkman linkman : list) {
			System.out.println(linkman);
		}
		tr.commit();
	}
	
	/**
	 * 演示QBC的or方法
	 */
	@Test
	public void run6(){
		Session session = HibernateUtils.getSession();
		Transaction tr = session.beginTransaction();
		// 建立QBC查詢介面
		Criteria criteria = session.createCriteria(Linkman.class);
		
		// SQL：select * from cst_linkman where lkm_gender = '女' or lkm_id > 3L;
		criteria.add(Restrictions.or(Restrictions.eq("lkm_gender", "女"), Restrictions.gt("lkm_id", 3L)));
		
		List<Linkman> list = criteria.list();
		for (Linkman linkman : list) {
			System.out.println(linkman);
		}
		tr.commit();
	}
	
	/**
	 * 判斷值是否為空
	 */
	@Test
	public void run7(){
		Session session = HibernateUtils.getSession();
		Transaction tr = session.beginTransaction();
		// 建立QBC查詢介面
		Criteria criteria = session.createCriteria(Linkman.class);
		
		// 找所有的lkm_email是空的值
		criteria.add(Restrictions.isNull("lkm_email"));
		
		List<Linkman> list = criteria.list();
		for (Linkman linkman : list) {
			System.out.println(linkman);
		}
		tr.commit();
	}
	
	/**
	 * 聚合函式的查詢
	 */
	@Test
	public void run8(){
		Session session = HibernateUtils.getSession();
		Transaction tr = session.beginTransaction();
		// 建立QBC查詢介面
		Criteria criteria = session.createCriteria(Linkman.class);
		// 設定聚合函式的方式
		List<Number> list = criteria.setProjection(Projections.count("lkm_id")).list();
		Long count = list.get(0).longValue();
		System.out.println(count);
		tr.commit();
	}
	
	/**
	 * 強調問題： select count(*) from 表，又想查select * from 表單，存在問題
	 */
	@Test
	public void run9(){
		Session session = HibernateUtils.getSession();
		Transaction tr = session.beginTransaction();
		// 建立QBC查詢介面
		Criteria criteria = session.createCriteria(Linkman.class);
		// 設定聚合函式的方式  select count(lkm_id) from 表;  5
		criteria.setProjection(Projections.count("lkm_id"));
		List<Number> list = criteria.list();
		Long count = list.get(0).longValue();
		System.out.println(count);
		
		criteria.setProjection(null);
		
		// 繼續查詢所有的聯絡人  select * from 表
		List<Linkman> mans = criteria.list();
		for (Linkman linkman : mans) {
			System.out.println(linkman);
		}
		
		tr.commit();
	}
	
	
	
	/**
	 * 演示離線條件物件
	 */
	@Test
	public void run10(){
		Session session = HibernateUtils.getSession();
		Transaction tr = session.beginTransaction();
		// 建立離線條件查詢的物件
		DetachedCriteria criteria = DetachedCriteria.forClass(Linkman.class);
		// 新增查詢的條件了
		criteria.add(Restrictions.eq("lkm_gender", "女"));
		
		// 查詢了
		List<Linkman> list = criteria.getExecutableCriteria(session).list();
		for (Linkman linkman : list) {
			System.out.println(linkman);
		}
		
		tr.commit();
	}
}

技術分析之SQL查詢方式（瞭解）

1. 基本語法
    Session session = HibernateUtils.getCurrentSession();
    Transaction tr = session.beginTransaction();

    SQLQuery sqlQuery = session.createSQLQuery("select * from cst_linkman where lkm_gender = ?");
    sqlQuery.setParameter(0,"男");
    sqlQuery.addEntity(Linkman.class);
    List<Linkman> list = sqlQuery.list();
    System.out.println(list);
    tr.commit();

package com.kunaly.test;

import java.util.Arrays;
import java.util.List;

import org.hibernate.SQLQuery;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.Test;

import com.kunaly.domain.Linkman;
import com.kunaly.utils.HibernateUtils;

/**
 * SQL的查詢方式
 * @author Administrator
 *
 */
public class Demo09 {

	/**
	 * 測試SQL 語句的查詢
	 */
	@Test
	public void run1(){
		Session session = HibernateUtils.getSession();
		Transaction tr = session.beginTransaction();
		// 建立的是SQL的查詢的介面
		SQLQuery query = session.createSQLQuery("select * from cst_linkman");
		//查詢資料
		List<Object[]> list = query.list();
		for(Object[] objects : list){
			System.out.println(Arrays.toString(objects));
		}
	}
	
	/**
	 * 把資料封裝到物件中	
	 */
	@Test
	public void run2(){
		Session session = HibernateUtils.getSession();
		Transaction tr = session.beginTransaction();
		// 建立的是SQL的查詢的介面
		SQLQuery query = session.createSQLQuery("select * from cst_linkman");
		//通過方法設定
		query.addEntity(Linkman.class);
		List<Linkman> list = query.list();
		for (Linkman linkman : list) {
			System.out.println(linkman.getLkm_name());
		}
		
		tr.commit();
		
	}
}

技術分析之HQL多表查詢

1. 多表的查詢進來使用HQL語句進行查詢，HQL語句和SQL語句的查詢語法比較類似。
    * 內連線查詢
        * 顯示內連線
            * select * from customers c inner join orders o on c.cid = o.cno;
        * 隱式內連線
            * select * from customers c,orders o where c.cid = o.cno;

    * 外連線查詢
        * 左外連線
            * select * from customers c left join orders o on c.cid = o.cno;
        * 右外連線
            * select * from customers c right join orders o on c.cid = o.cno;

2. HQL的多表查詢
    * 迫切和非迫切：
        * 非迫切返回結果是Object[]
        * 迫切連線返回的結果是物件，把客戶的資訊封裝到客戶的物件中，把訂單的資訊封裝到客戶的Set集合中。

3. 內連線查詢
    * 內連線使用 inner join ，預設返回的是Object陣列
        Session session = HibernateUtils.getCurrentSession();
        Transaction tr = session.beginTransaction();
        List<Object[]> list = session.createQuery("from Customer c inner join c.linkmans").list();
        for (Object[] objects : list) {
            System.out.println(Arrays.toString(objects));
        }
        tr.commit();

    * 迫切內連線:inner join fetch ，返回的是實體物件
        Session session = HibernateUtils.getCurrentSession();
        Transaction tr = session.beginTransaction();
        List<Customer> list = session.createQuery("from Customer c inner join fetch c.linkmans").list();
        Set<Customer> set = new HashSet<Customer>(list);
        for (Customer customer : set) {
            System.out.println(customer);
        }
        tr.commit();

4. 左外連線查詢
    * 左外連線: 封裝成List<Object[]>

    * 迫切左外連線
        Session session = HibernateUtils.getCurrentSession();
        Transaction tr = session.beginTransaction();
        List<Customer> list = session.createQuery("from Customer c left join fetch c.linkmans").list();
        Set<Customer> set = new HashSet<Customer>(list);
        for (Customer customer : set) {
            System.out.println(customer);
        }        tr.commit();

hibernate中hql查詢
2018-11-09
Hibernate查詢自動更新
2019-01-19
hibernate查詢的方式都有哪些
2020-11-01
hibernate的三種查詢方式
2021-04-21
Hibernate-ORM:13.Hibernate中的連線查詢
2018-06-04
ORM
391、Java框架46 -【Hibernate - 查詢HQL、查詢Criteria、查詢標準SQL】 2020.10.19
2020-10-19
Java框架SQL
Hibernate【查詢、連線池、逆向工程】
2019-03-04
hibernate異常之--count查詢異常
2020-04-04
Hibernate5.1+Sqlserver2000分頁查詢
2021-09-09
SQLServer
如何使用Hibernate/JPA的JPQL/HQL查詢提取？
2019-02-09
如何啟用Hibernate慢查詢日誌？ -Vlad Mihalcea
2020-02-26
Hibernate中不支援複雜子查詢from (select ……)解決方案
2018-09-18
如何在Hibernate/JPA的實體和查詢中使用Java 8 Optional？
2019-02-09
Java
SQL查詢的：子查詢和多表查詢
2020-11-18
SQL
mysql-分組查詢-子查詢-連線查詢-組合查詢
2020-12-22
MySql
複雜查詢—子查詢
2020-11-16
查詢——二分查詢
2020-09-18
MYSQL學習筆記25: 多表查詢(子查詢)[標量子查詢,列子查詢]
2024-03-10
MySql筆記
查詢演算法__Fibonacci查詢
2019-03-06
演算法
group by,having查詢 ”每**“的查詢
2018-04-25
Elasticsearch複合查詢——boosting查詢
2021-11-17
Elasticsearch
離線查詢與線上查詢
2018-12-11
查詢演算法__插值查詢
2019-03-06
演算法
oracle 精確查詢和模糊查詢
2019-11-19
Oracle
pgsql查詢優化之模糊查詢
2019-07-20
SQL優化
MySQL - 資料查詢 - 簡單查詢
2020-12-27
MySql
SSH：hiberate實現資料的查詢（單查詢和全查詢）
2019-01-01
21億Q綁查詢21億Q綁查詢21億Q綁查詢21億Q綁查詢21億Q綁查詢
2024-05-09
Spring Data Jpa 的簡單查詢多表查詢HQL，SQL ，動態查詢， QueryDsl ，自定義查詢筆記
2018-08-15
SpringSQL筆記
Java ——MongDB 插入資料、模糊查詢、in查詢
2018-08-10
Java
mysql查詢結果多列拼接查詢
2018-08-17
MySql
資料庫高階查詢之子查詢
2018-07-15
資料庫
查詢最佳化——查詢樹結構
2024-03-12
Solr複雜查詢一：函式查詢
2020-04-17
Solr函式
查詢演算法__二分查詢
2019-03-05
演算法
Elasticsearch中的Term查詢和全文查詢
2021-07-06
Elasticsearch
MySQL之連線查詢和子查詢
2021-09-04
MySql
mysql查詢語句5：連線查詢
2020-12-22
MySql

Hibernate 查詢

相關文章