Hibernate多表查询连接操作

 

SQL多表操作分类;

1.交叉连接:select*from t_customer cross Join t_order;

2.显示内连接: select*from t_customer c inner join t_order o on c.id=o.c_customer_id;

　隐示内连接:select*from t_customer c ,t_order o WHERE c.id=o.c_customer_id; where可消除笛卡尔积

 笛卡尔积是两个表任意组合,查询出两表全部的组合,但我们只想查询某一种组合,加where限制条件可消除笛卡尔积.

3.外链接:select*from t_customer c left join t_order o ON c.id=o.c_customer_id;左外:把左边的全部显示出来.

Hql多表操作分类:

1.交叉连接 ::select*from t_customer cross Join t_order;

2.内连接

a) 显示内连接:       b) 隐式内连接      c) 迫切内连接

//显示内连接---结果Customer的id=1的属性,order属性;Customer的id=1的属性,order属性
    @Test
    public void test010(){
        Session session = HibernateUtils.openSession();
        session.beginTransaction();
        String hql="from Customer c inner join c.orders with c.id=1";
        Query query = session.createQuery(hql);
        List<Object[]> list = query.list();
        for (Object[] objects : list) {
            for (Object object : objects) {
                System.out.println(object );
            }
        }
        session.getTransaction();
        session.close();
    }
    //隐示内连接----消除了笛卡尔迪.它是通过"."运算符来关联.
        @Test
        public void test011(){
            Session session = HibernateUtils.openSession();
            session.beginTransaction();
            String hql="from Order o where o.c.id=1";
            Query query = session.createQuery(hql);
             List list = query.list();
            System.out.println(list);
            
            session.getTransaction();
            session.close();
        }
        //迫切内连接(立即加载)----distinct c 消除了笛卡尔迪,迫切内连接得到的结果是直接封装到po类,而内连接得到的结果是Object[],数组中封装的po类.
        @Test
        public void test012(){
            Session session = HibernateUtils.openSession();
            session.beginTransaction();
            //底层也是inner join,只不过把结果封装到对象中.
            String hql=" select distinct c from Customer c inner join fetch c.orders ";
            
            Query query = session.createQuery(hql);
            List<Customer> list = query.list();//集合中装入的是from后面的对象
            for (Customer c : list) {
                System.out.println(c);
            }
            session.getTransaction();
            session.close();
        }

 

3.外连接

1)左外连接           2)迫切左外连接               3)右外连接

//外链接
                @Test
                public void test013(){
                    Session session = HibernateUtils.openSession();
                    session.beginTransaction();
                    //底层也是inner join,只不过把结果封装到对象中.
                    String hql=" from Customer c left join c.orders ";
                    Query query = session.createQuery(hql);
                    List<Object[]>list = query.list();
                    for (Object[] objects : list) {
                        for (Object object : objects) {
                            System.out.println(object+"	");
                        }
                        System.out.println();
                    }
                    session.getTransaction();
                    session.close();
                }
                //迫切左外链接
                @Test
                public void test014(){
                    Session session = HibernateUtils.openSession();
                    session.beginTransaction();
                    //底层也是inner join,只不过把结果封装到对象中.
                    String hql=" select distinct c from Customer c left join fetch c.orders where c.id=1";
                    Query query = session.createQuery(hql);
                    List<Customer> list = query.list();
                    /*for (Customer c : list) {
                        System.out.println(c);
                    }*/
                    System.out.println(list);
                    session.getTransaction();
                    session.close();
                }

 

注意:在Hibernate中有迫切连接,在sql中没有.