How to use

setFetchMode

method

in

org.hibernate.Criteria

/**
 * Set the fetch mode for a given association
 *
 * @param associationPath The association path
 * @param mode The fetch mode to apply
 *
 * @return {@code this}, for method chaining
 */
public DetachedCriteria setFetchMode(String associationPath, FetchMode mode) {
  criteria.setFetchMode( associationPath, mode );
  return this;
}

 //DAO
@Override
public Person findPersonWithRoles(UUID personId){
  Criteria criteria = sessionFactory.getCurrentSession().createCritiera(Person.class);

  criteria.add(Restrictions.idEq(personId);
  criteria.setFetchMode("roles", FetchMode.SUBSELECT);
}

  protected Criteria getCriteria(Session s) {
    // should use RootEntityTransformer by default
    return s.createCriteria( Student.class, "s" )
        .setFetchMode( "enrolments", FetchMode.JOIN )
        .addOrder( Order.asc( "s.studentNumber" ) );
  }
};

  protected Criteria getCriteria(Session s) {
    return s.createCriteria( Student.class, "s" )
        .createAlias( "s.preferredCourse", "pc", Criteria.LEFT_JOIN  )
        .setFetchMode( "enrolments", FetchMode.JOIN )
        .setResultTransformer( Transformers.ALIAS_TO_ENTITY_MAP );
  }
};

  protected Criteria getCriteria(Session s) {
    // should use RootEntityTransformer by default
    return s.createCriteria( Student.class, "s" )
        .setFetchMode( "preferredCourse", FetchMode.JOIN )
        .addOrder( Order.asc( "s.studentNumber") );
  }
};

  protected Criteria getCriteria(Session s) {
    // should use RootEntityTransformer by default
    return s.createCriteria( Student.class, "s" )
        .setFetchMode( "addresses", FetchMode.JOIN )
        .addOrder( Order.asc( "s.studentNumber") );
  }
};

  protected Criteria getCriteria(Session s) {
    // should use RootEntityTransformer by default
    return s.createCriteria( Student.class, "s" )
        .setFetchMode( "enrolments", FetchMode.SELECT )
        .addOrder( Order.asc( "s.studentNumber" ) );
  }
};

  protected Criteria getCriteria(Session s) {
    // should use RootEntityTransformer by default
    return s.createCriteria( Student.class, "s" )
        .createAlias( "s.preferredCourse", "pCourse", Criteria.LEFT_JOIN )
        .setFetchMode( "preferredCourse", FetchMode.JOIN )
        .addOrder( Order.asc( "s.studentNumber") );
  }
};

  protected Criteria getCriteria(Session s) {
    // should use RootEntityTransformer by default
    return s.createCriteria( Student.class, "s" )
        .createCriteria( "s.addresses", "a", Criteria.LEFT_JOIN )
        .setFetchMode( "a", FetchMode.JOIN )
        .addOrder( Order.asc( "s.studentNumber") );
  }
};

  protected Criteria getCriteria(Session s) {
    // should use RootEntityTransformer by default
    return s.createCriteria( Student.class, "s" )
        .createAlias( "s.addresses", "a", Criteria.LEFT_JOIN )
        .setFetchMode( "addresses", FetchMode.JOIN )
        .addOrder( Order.asc( "s.studentNumber") );
  }
};

  protected Criteria getCriteria(Session s) {
    // should use RootEntityTransformer by default
    return s.createCriteria( Student.class, "s" )
        .createAlias( "s.addresses", "a", Criteria.LEFT_JOIN )
        .setFetchMode( "a", FetchMode.JOIN )
        .addOrder( Order.asc( "s.studentNumber") );
  }
};

  protected Criteria getCriteria(Session s) {
    // should use RootEntityTransformer by default
    return s.createCriteria( Student.class, "s" )
        .createAlias( "s.preferredCourse", "pCourse", Criteria.LEFT_JOIN )
        .setFetchMode( "pCourse", FetchMode.JOIN )
        .addOrder( Order.asc( "s.studentNumber") );
  }
};

  protected Criteria getCriteria(Session s) {
    // should use RootEntityTransformer by default
    return s.createCriteria( Student.class, "s" )
        .createCriteria( "s.preferredCourse", "pCourse", Criteria.LEFT_JOIN )
        .setFetchMode( "pCourse", FetchMode.JOIN )
        .addOrder( Order.asc( "s.studentNumber") );
  }
};

  protected Criteria getCriteria(Session s) {
    // should use RootEntityTransformer by default
    return s.createCriteria( Student.class, "s" )
        .createCriteria( "s.preferredCourse", "pCourse", Criteria.LEFT_JOIN )
        .setFetchMode( "preferredCourse", FetchMode.JOIN )
        .addOrder( Order.asc( "s.studentNumber") );
  }
};

  protected Criteria getCriteria(Session s) {
    return s.createCriteria( Student.class, "s" )
        .createAlias( "s.preferredCourse", "pc", Criteria.LEFT_JOIN  )
        .setFetchMode( "enrolments", FetchMode.JOIN )
        .addOrder( Order.asc( "s.studentNumber") );
  }
};

  protected Criteria getCriteria(Session s) {
    // should use RootEntityTransformer by default
    return s.createCriteria( Student.class, "s" )
        .createCriteria( "s.addresses", "a", Criteria.LEFT_JOIN )
        .setFetchMode( "addresses", FetchMode.JOIN )
        .addOrder( Order.asc( "s.studentNumber") );
  }
};

  protected Criteria getCriteria(Session s) {
    return s.createCriteria( Student.class, "s" )
        .createAlias( "s.preferredCourse", "pc", Criteria.LEFT_JOIN  )
        .setFetchMode( "enrolments", FetchMode.JOIN )
        .addOrder( Order.asc( "s.studentNumber" ))
        .setResultTransformer( Transformers.ALIAS_TO_ENTITY_MAP );
  }
};

  protected Criteria getCriteria(Session s) {
    // should use RootEntityTransformer by default
    return s.createCriteria( Enrolment.class, "e" )
        .createAlias( "e.student", "s", Criteria.LEFT_JOIN )
        .setFetchMode( "student", FetchMode.JOIN )
        .setFetchMode( "student.preferredCourse", FetchMode.JOIN )
        .setProjection(
            Projections.projectionList()
                .add( Projections.property( "s.name" ) )
                .add( Projections.property( "e.student" ) )
        )
        .addOrder( Order.asc( "s.studentNumber") );
  }
};

@Test
@SuppressWarnings( "unchecked" )
public void test3() {
  doInHibernate( this::sessionFactory, s -> {
    List<Person> persons = (List<Person>) s.createCriteria( Person.class ).setFetchMode( "vehicle", FetchMode.JOIN ).list();
    for ( Person person : persons ) {
      if ( shouldHaveVehicle( person ) ) {
        assertNotNull( person.getVehicle() );
        assertNotNull( person.getVehicle().getDriver() );
      }
    }
  } );
}

@Test
@SuppressWarnings( "unchecked" )
public void test4() {
  List<Vehicle> vehicles;
  try ( Session s = openSession() ) {
    vehicles = (List<Vehicle>) s.createCriteria( Vehicle.class ).setFetchMode( "driver", FetchMode.JOIN ).list();
  }
  for ( Vehicle vehicle : vehicles ) {
    if ( shouldHaveDriver( vehicle ) ) {
      assertNotNull( vehicle.getDriver() );
      assertNotNull( vehicle.getDriver().getVehicle() );
    }
  }
}