Tabnine Logo
Criteria.setFetchMode
Code IndexAdd Tabnine to your IDE (free)

How to use
setFetchMode
method
in
org.hibernate.Criteria

Best Java code snippets using org.hibernate.Criteria.setFetchMode (Showing top 20 results out of 360)

origin: hibernate/hibernate-orm

/**
 * 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;
}
origin: stackoverflow.com

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

  criteria.add(Restrictions.idEq(personId);
  criteria.setFetchMode("roles", FetchMode.SUBSELECT);
}
origin: hibernate/hibernate-orm

  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" ) );
  }
};
origin: hibernate/hibernate-orm

  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 );
  }
};
origin: hibernate/hibernate-orm

  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" ) );
  }
};
origin: hibernate/hibernate-orm

  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") );
  }
};
origin: hibernate/hibernate-orm

  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") );
  }
};
origin: hibernate/hibernate-orm

  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") );
  }
};
origin: hibernate/hibernate-orm

  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") );
  }
};
origin: hibernate/hibernate-orm

  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") );
  }
};
origin: hibernate/hibernate-orm

  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") );
  }
};
origin: hibernate/hibernate-orm

  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") );
  }
};
origin: hibernate/hibernate-orm

  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") );
  }
};
origin: hibernate/hibernate-orm

  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") );
  }
};
origin: hibernate/hibernate-orm

  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") );
  }
};
origin: hibernate/hibernate-orm

  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") );
  }
};
origin: hibernate/hibernate-orm

  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 );
  }
};
origin: hibernate/hibernate-orm

  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") );
  }
};
origin: hibernate/hibernate-orm

@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() );
      }
    }
  } );
}
origin: hibernate/hibernate-orm

@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() );
    }
  }
}
org.hibernateCriteriasetFetchMode

Javadoc

Specify an association fetching strategy for an association or a collection of values.

Popular methods of Criteria

  • list
    Get the results.
  • add
    Add a Criterion to constrain the results to be retrieved.
  • uniqueResult
    Convenience method to return a single instance that matches the query, or null if the query returns
  • addOrder
    Add an Order to the result set.
  • setProjection
    Used to specify that the query results will be a projection (scalar in nature). Implicitly specifies
  • setMaxResults
    Set a limit upon the number of objects to be retrieved.
  • setFirstResult
    Set the first result to be retrieved.
  • setResultTransformer
    Set a strategy for handling the query results. This determines the "shape" of the query result.
  • createAlias
    Join an association using the specified join-type, assigning an alias to the joined association. The
  • createCriteria
    Create a new Criteria, "rooted" at the associated entity, using the specified join type.
  • setCacheable
    Enable caching of this query result, provided query caching is enabled for the underlying session fa
  • setFetchSize
    Set a fetch size for the underlying JDBC query.
  • setCacheable,
  • setFetchSize,
  • scroll,
  • setLockMode,
  • setReadOnly,
  • setCacheRegion,
  • setTimeout,
  • setCacheMode,
  • setFlushMode

Popular in Java

  • Start an intent from android
  • putExtra (Intent)
  • setScale (BigDecimal)
  • getContentResolver (Context)
  • FileNotFoundException (java.io)
    Thrown when a file specified by a program cannot be found.
  • String (java.lang)
  • SocketTimeoutException (java.net)
    This exception is thrown when a timeout expired on a socket read or accept operation.
  • URL (java.net)
    A Uniform Resource Locator that identifies the location of an Internet resource as specified by RFC
  • Collection (java.util)
    Collection is the root of the collection hierarchy. It defines operations on data collections and t
  • GregorianCalendar (java.util)
    GregorianCalendar is a concrete subclass of Calendarand provides the standard calendar used by most
  • CodeWhisperer alternatives
Tabnine Logo
  • Products

    Search for Java codeSearch for JavaScript code
  • IDE Plugins

    IntelliJ IDEAWebStormVisual StudioAndroid StudioEclipseVisual Studio CodePyCharmSublime TextPhpStormVimGoLandRubyMineEmacsJupyter NotebookJupyter LabRiderDataGripAppCode
  • Company

    About UsContact UsCareers
  • Resources

    FAQBlogTabnine AcademyTerms of usePrivacy policyJava Code IndexJavascript Code Index
Get Tabnine for your IDE now