package com.baidu.test;

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

import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.service.ServiceRegistryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import com.baidu.leftJoin.Department;
import com.baidu.leftJoin.Employee;

public class TestHQL_LeftJoin {
	
	private SessionFactory sessionFactory;
	private Session session;
	private Transaction transaction;
	
	
	@Before
	public void init(){
		Configuration configuration = new Configuration().configure();
		ServiceRegistry serviceRegistry = new ServiceRegistryBuilder()
										.applySettings(configuration.getProperties())
										.buildServiceRegistry();
		
		sessionFactory = configuration.buildSessionFactory(serviceRegistry);
		
		session = sessionFactory.openSession();
		transaction = session.beginTransaction();
	}
	@After
	public void destroy(){
		transaction.commit();
		session.close();
		sessionFactory.close();
		
	}
	
//  ~~~~~~~~~~~~~~~~~~~~~~~~~~下面的例子是 從 1 對  多   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	
	/**
	 * 
	 * 迫切左外連線: 特點是：如果左表有不滿足條件的，也返回左表不滿足條件
	 *		1. LEFT JOIN FETCH 關鍵字表示迫切左外連線檢索策略.
	 *		2. list() 方法返回的集合中存放實體物件的引用, 每個 Department 物件關聯的 Employee 集合都被初始化,
	 *		 	存放所有關聯的 Employee 的實體物件. 
	 *		3. 查詢結果中可能會包含重複元素, 可以通過一個 HashSet 來過濾重複元素
	 * 
	 * 		去重：
	 * 			方法一:使用 distinct
	 * 				String hql  = "SELECT DISTINCT d FROM  Department d LEFT JOIN FETCH d.emps ";
	 *				Query query = session.createQuery(hql);
	 *
	 *				List<Department> depts = query.list();
	 *				System.out.println(depts.size());
	 * 			
	 * 			方法二
	 * 		 		String hql  = "FROM  Department d LEFT JOIN FETCH d.emps ";
	 *				Query query = session.createQuery(hql);
	 *
	 *				List<Department> depts = query.list();
	 *
	 *				depts = new ArrayList<>(new LinkedHashSet(depts));
	 *				System.out.println(depts.size());
	 *				
	 *				for(Department dept:depts){
	 *					System.out.println(dept.getName() + "--" + dept.getEmps().size() );
	 *				}
	 * 
	 * 
	 */
	@Test
	public void testLeftJoinFetch(){
//		String hql  = "SELECT DISTINCT d FROM  Department d LEFT JOIN FETCH d.emps ";
//		Query query = session.createQuery(hql);
//		
//		List<Department> depts = query.list();
//		System.out.println(depts.size());
//		
		
		
		String hql  = "FROM  Department d LEFT JOIN FETCH d.emps ";
		Query query = session.createQuery(hql);
		
		
		List<Department> depts = query.list();
		System.out.println(depts.size());
		
		depts = new ArrayList<>(new LinkedHashSet(depts));
		System.out.println(depts.size());
		
		for(Department dept:depts){
			System.out.println(dept.getName() + "--" + dept.getEmps().size() );
		}
	}
	
	
	/** 
	 * 左外連線: 
	 *		1. LEFT JOIN 關鍵字表示左外連線查詢. 
	 *		2. list() 方法返回的集合中存放的是物件陣列型別
	 *		3. 根據配置檔案來決定 Employee 集合的檢索策略. 
	 *		4. 如果希望 list() 方法返回的集合中僅包含 Department 物件, 
	 *			可以在HQL 查詢語句中使用 SELECT 關鍵字
	 *		
	 *		這樣的語句查詢的結果有重複：
	 *			String hql = "FROM Department d LEFT JOIN d.emps";
	 *			Query query = session.createQuery(hql);
	 *		
	 *			List<Object[]> results = query.list();
	 *			System.out.println(results.size());
	 *	
	 * 		去重：
	 * 			僅能使用  distinct 的方法去除重複
	 * 	
	 * 			String hql = "SELECT DISTINCT d FROM Department d LEFT JOIN d.emps";
	 * 			Query query = session.createQuery(hql);
	 * 
	 * 			List<Department> depts = query.list();
	 * 			System.out.println(depts.size());
	 * 				
	 * 			for(Department dept:depts){
	 * 				System.out.println(dept.getName() + dept.getEmps().size());
	 * 			}
	 * 
	 */
	@Test
	public void testLeftJoin(){
		String hql = "SELECT DISTINCT d FROM Department d LEFT JOIN d.emps";
		Query query = session.createQuery(hql);
		
		List<Department> depts = query.list();
		System.out.println(depts.size());
		
		for(Department dept:depts){
			System.out.println(dept.getName() + dept.getEmps().size());
		}		
		
	}
	
	/**
	 * 迫切內連線: 特點是：不返回左表不滿足條件
	 *		INNER JOIN FETCH 關鍵字表示迫切內連線, 也可以省略 INNER 關鍵字
	 *		list() 方法返回的集合中存放 Department 物件的引用, 每個 Department 
	 *				物件的 Employee 集合都被初始化, 存放所有關聯的 Employee 物件
	 * 
	 * 內連線:
	 *		INNER JOIN 關鍵字表示內連線, 也可以省略 INNER 關鍵字
	 *		list() 方法的集合中存放的每個元素對應查詢結果的一條記錄, 每個元素都是物件陣列型別
	 *		如果希望 list() 方法的返回的集合僅包含 Department  物件, 可以在 HQL 查詢語句中使用 SELECT 關鍵字
	 *
	 * 
	 * 
	 */
	@Test
	public void testInnerJoinFetch(){
		//String hql  = "SELECT DISTINCT d FROM  Department d LEFT JOIN FETCH d.emps ";
		String hql  = "FROM  Department d INNER JOIN FETCH  d.emps ";
		Query query = session.createQuery(hql);
		
		
		List<Department> depts = query.list();
		depts = new ArrayList<>(new LinkedHashSet(depts));
		System.out.println(depts.size());
		
		for(Department dept:depts){
			System.out.println(dept.getName() + "--" + dept.getEmps().size() );
		}
	}
	
	
//  ~~~~~~~~~~~~~~~~~~~~~~~~~~下面的例子是 從多 對  1   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	
	@Test
	public void testLeftJoinFetch2(){
		String hql = "FROM Employee e LEFT JOIN FETCH e.dept";
		Query query = session.createQuery(hql);
		
		List<Employee> emps = query.list();
		System.out.println(emps.size());
		
		for(Employee emp:emps){
			System.out.println(emp + " -- " + emp.getDept());
		}
		
	}
}