`
newleague
  • 浏览: 1499807 次
  • 性别: Icon_minigender_1
  • 来自: 深圳
社区版块
存档分类

Hibernate inner join fetch,left join fet

阅读更多

inner join fetch
/**
* 一对多中的一方inner join fetch多方
* 这里不能用inner join on
* 查询结果是它把一方对多方的那个集合里面的对象都查询出来放到一方的集合中
*/
public List getallByinnerjoinTShop(){
   List list=null;
   try {
    Query query=this.GetSession().createQuery("from TType as t inner join fetch t.TShops");
    list=query.list();
   } catch (HibernateException e) {
    throw e;
   }finally{
    this.ColseSession();
   }
   return list;
}
测试:
List list=typedao.getallByinnerjoinTShop();
   Iterator iter=list.iterator();
   while(iter.hasNext()){
    TType type=(TType) iter.next();
    System.out.println(type.toString());
    Iterator<TShop> it=type.getTShops().iterator();
    while(it.hasNext()){
     TShop sh=it.next();
     System.out.println(sh.toString());
    }
   }

left join fetch
/**
* left join fetch 左外连接
*/
public List getallLeftjoinfetchTShop(){
   List list=null;
   try {
    Query query=this.GetSession().createQuery("from TType as t left join fetch t.TShops");
    list=query.list();
   } catch (HibernateException e) {
    throw e;
   }finally{
    this.ColseSession();
   }
   return list;
}
测试:
List list=typedao.getallLeftjoinfetchTShop();
   Iterator iter=list.iterator();
   while(iter.hasNext()){
    TType type=(TType) iter.next();
    System.out.println(type.toString());
    Iterator<TShop> it=type.getTShops().iterator();
    while(it.hasNext()){
     TShop sh=it.next();
     System.out.println(sh.toString());
    }
   }

left join
/**
* left join 左外连接
*
*/
public List getallLeftjoinTShop(){
   List list=null;
   try {
    Query query=this.GetSession().createQuery("from TType as t left join t.TShops");
    list=query.list();
   } catch (HibernateException e) {
    throw e;
   }finally{
    this.ColseSession();
   }
   return list;
}
测试:
List list=typedao.getallLeftjoinTShop();
   Iterator iter=list.iterator();
   while(iter.hasNext()){
    Object[] obj=(Object[]) iter.next();
    TType type=(TType) obj[0];
    TShop shop=(TShop) obj[1];
    System.out.println(type.toString());
    //访问type对象里面的TShops集合里的元素,有懒加载问题
    //Iterator<TShop> it=type.getTShops().iterator();
    //while(it.hasNext()){
    //TShop sh=it.next();
    //System.out.println(sh.toString());
    //}
    //from TType as t left join t.TShops shop可能为空
    if(shop!=null){
     System.out.println(shop.toString());
    }  
   }
隐式内连接
/**
* 隐式内连接
*/
public List getall(){
   List list=null;
   try {
    Query query=this.GetSession().createQuery("from TType as t,TShop as s where s.TType=t");
    list=query.list();
   } catch (HibernateException e) {
    throw e;
   }finally{
    this.ColseSession();
   }
   return list;
}
测试:
List list=typedao.getall();
   Iterator iter=list.iterator();
   while(iter.hasNext()){
    Object[] obj=(Object[]) iter.next();
    TType type=(TType) obj[0];
    TShop shop=(TShop) obj[1];
    System.out.println(type);
    System.out.println(shop);
   }


集合过滤
/**
* 集合过滤
*/
public List getallfilter(int price){
   List list=null;
   try {
    Query query=this.GetSession().createQuery("from TType");
    list=query.list();
    Iterator iter=list.iterator();
    while(iter.hasNext()){
     TType type=(TType) iter.next();
     Query que=this.GetSession().createFilter(type.getTShops(), "where SPrice>=?");
     que.setInteger(0, price);
     List arr=que.list();
     type.setTShops(new HashSet(arr));
    }
   } catch (HibernateException e) {
    throw e;
   }finally{
    this.ColseSession();
   }
   return list;
}
测试:
List list=typedao.getallfilter(10);
   Iterator iter=list.iterator();
   while(iter.hasNext()){
    TType type=(TType) iter.next();
    System.out.println(type.toString());
    Iterator<TShop> it=type.getTShops().iterator();
    while(it.hasNext()){
     TShop sh=it.next();
     System.out.println(sh.toString());
    }
   }

分享到:
评论

相关推荐

    Hibernate Fetch 的作用

    例如,在上面的代码片段中,通过`left outer join fetch parent.childs`语句,我们告诉Hibernate在加载`Parent`实体时,也一并加载所有相关的`Child`实体。这样,即使`Parent`实体的`childs`属性被标记为`lazy="true...

    HQL Hibernate查询语言

    HQL Hibernate 查询语言 HQL(Hibernate Query Language)是 Hibernate 中的一种强大的查询语言,它看起来很像 SQL,但是不要被...例如:from Cat as cat inner join fetch cat.mate left join fetch cat.kittens。

    nhibernate-linq-innerjoin-fetch:扩展Linq提供程序以支持Inner join渴望获取

    NHibernate Linq内部加入获取提供商 这个简单的库旨在为NHibernate提供支持,以执行内部联接渴望获取。 启用内部联接 致电 NHibernateInnerJoinSupport.Enable() 必须在NHibernate初始化之前的任何时间执行 ...

    hsql查询语法

    from Cat as cat inner join fetch cat.mate left join fetch cat.kittens 这个语句将Cat类的实例与其mate和kittens之间的关系进行关联和连接,并将相关联的对象随着父对象的初始化而被初始化。 需要注意的是,...

    Hibernate HQL.doc

    HQL支持四种类型的连接:inner join(内连接)、left outer join(左外连接)、right outer join(右外连接)和full join(全连接)。简写形式如`join`和`left join`也是允许的。`fetch`连接用于一次性初始化相关联...

    hibernate 中 fetch=FetchType.LAZY 懒加载失败处理方法

    hibernate 中 fetch=FetchType.LAZY 懒加载失败处理方法 Hibernate 中 fetch=FetchType.LAZY 懒加载失败处理方法是 Hibernate 框架中的一种常见问题。当我们在 Hibernate 中使用懒加载特性时,可能会遇到 ...

    HIBERNATE HQL

    例如,`from Cat as cat inner join fetch cat.mate left join fetch cat.kittens`。 - 使用 `fetch all properties` 可以强制Hibernate立即加载那些默认情况下需要延迟加载的属性,从而提高第一次查询时的数据完整...

    hibernate的hql语句

    连接类型包括:`inner join`(内连接)、`left outer join`(左外连接)、`right outer join`(右外连接)和`full join`(全连接)。`join`的简写形式如`from Cat as cat join cat.kittens as kitten`,简化了查询...

    Hibernate_HQL大全

    4. **JOIN与ASSOCIATION**:HQL支持INNER JOIN、LEFT OUTER JOIN、RIGHT OUTER JOIN和FULL JOIN四种连接类型。通过JOIN关键字,HQL能够处理实体间的关联,从而实现对关联实体的查询。例如,“JOIN cat.mate as mate...

    hibernate 的HQL 语言入门与提高

    `join` 关键字支持不同类型的连接,包括 `inner join`(内连接)、`left outer join`(左外连接)、`right outer join`(右外连接)和 `full join`(全连接)。简写形式如 `join` 和 `left join` 也常被使用。此外,...

    HQL语句大全

    - 示例:`from Cat as cat join fetch cat.mate left join fetch cat.kittens`。 - **限制**:`fetch`连接不能在使用`scroll()`或`iterate()`方法的查询中使用;也不能使用`full join fetch`或`right join fetch`。...

    Hibernate查询语言(HQL)

    INNER JOIN FETCH cat.mate; ``` 使用 FETCH 可以提高查询效率,避免多次查询数据库加载关联对象。注意,FETCH 通常与 ITERATE 方法结合使用,而不是 SCROLL 或其他方法,因为 SCROLL 等方法可能不支持懒加载。 ...

    Hibernate查询语言

    HQL支持多种类型的连接,如内连接(inner join)、左外连接(left outer join)、右外连接(right outer join)和全连接(full join)。例如: ```sql from Cat as cat inner join cat.mate as mate left outer join...

    Hibernate查询语言(HQL) 语法参考

    from Cat as cat inner join fetch cat.mate ``` 这将返回 Cat 类的实例和它的 mate 关联对象,并将相关联的对象初始化。 select 子句 select 子句选择将哪些对象与属性返回到查询结果集中,例如: ``` select cat...

    HQL语言教程[归类].pdf

    例如,`from Cat as cat inner join fetch cat.mate left join fetch cat.kittens`。需要注意的是,`fetch`连接不适用于`iterate()`查询,且不应与`setMaxResults()`或`setFirstResult()`一起使用。 总的来说,HQL...

    HQL详解

    其中,`INNER JOIN`、`LEFT OUTER JOIN`和`RIGHT OUTER JOIN`可以简化为: ``` FROM Cat AS cat JOIN cat.mate AS mate LEFT JOIN cat.kittens AS kitten ``` 此外,`FETCH`连接允许在一个选择语句中同时初始化父...

    hibernate的使用心得

    Hibernate支持多种连接类型,包括`inner join`(内连接)、`left outer join`(左外连接)、`right outer join`(右外连接)和`full join`(全连接)。`with`关键字用于提供额外的连接条件,类似于SQL中的`on`关键字...

    hibernate hql基本操作

    例如`from Cat as cat inner join fetch cat.mate`。 - **Fetch连接注意事项**:`fetch`连接一般不需要为关联对象指定别名,因为这些关联对象不会直接出现在查询结果中,而是通过它们的父对象来访问。此外,在使用`...

    hql语句经典教程

    from Cat as cat inner join fetch cat.mate left join fetch cat.kittens ``` 这将在查询时初始化关联的伴侣猫和幼猫集合。请注意,`fetch`连接通常不用于`where`子句,也不直接返回结果集,而是通过父对象访问。...

    hql语句大全hql语句大全

    这表示,将`Cat`实体与`mate`和`kittens`关联的实体进行连接,其中`INNER JOIN`确保只有当关联实体存在时才返回`Cat`实体,而`LEFT OUTER JOIN`则保证即使没有关联实体,`Cat`实体也会被返回。 ##### 4. FETCH子句 ...

Global site tag (gtag.js) - Google Analytics