How to use

find

method

in

org.hibernate.engine.spi.SessionImplementor

@Override
public <T> T find(Class<T> entityClass, Object primaryKey) {
  return delegate.find( entityClass, primaryKey );
}

@Override
public <T> T find(Class<T> entityClass, Object primaryKey, LockModeType lockMode) {
  return delegate.find( entityClass, primaryKey, lockMode );
}

@Override
public <T> T find(Class<T> entityClass, Object primaryKey, LockModeType lockMode, Map<String, Object> properties) {
  return delegate.find( entityClass, primaryKey, lockMode, properties );
}

@Override
public <T> T find(Class<T> entityClass, Object primaryKey, Map<String, Object> properties) {
  return delegate.find( entityClass, primaryKey, properties );
}

@Test
public void testHqlWithFetch() {
  inTransaction(
      s -> {
        Parent dbParent = s.find( Parent.class, this.parent.getId() );
        Set<Child> children = dbParent.getChildren();
        assertEquals( 1, children.size() );
      }
  );
}

@Test
public void testHqlWithFetch() {
  inTransaction(
      s -> {
        Parent parent = s.find( Parent.class, this.parent.getId() );
        assertEquals( 1, parent.getChildren().size() );
      }
  );
}

inTransaction(
    session -> {
      session.find( Item.class, item.getId(), LockModeType.PESSIMISTIC_WRITE );
          secondSession -> {
            try {
              secondSession.find(
                  Item.class,
                  item.getId(),

@Test
@TestForIssue( jiraKey = "HHH-3930" )
public void testEagerFetchBidirectionalOneToOneWithDirectFetching() {
  inTransaction( session -> {
    EntityA a = new EntityA( 1L, new EntityB( 2L ) );
    
    session.persist( a );
    session.flush();
    session.clear();
    // Use atomic integer because we need something mutable
    final AtomicInteger queryExecutionCount = new AtomicInteger();
    
    session.getEventListenerManager().addListener( new StatisticalLoggingSessionEventListener() {
      @Override
      public void jdbcExecuteStatementStart() {
        super.jdbcExecuteStatementStart();
        queryExecutionCount.getAndIncrement();
      }
    } );
    
    session.find( EntityA.class, 1L );
    
    assertEquals(
        "Join fetching inverse one-to-one didn't use the object already present in the result set!",
        1,
        queryExecutionCount.get()
    );
  } );
}

inTransaction(
    session -> {
      session.find( Item.class, item.getId(), LockModeType.PESSIMISTIC_WRITE );

inTransaction(
    session -> {
      session.find( Item.class, item.getId(), LockModeType.PESSIMISTIC_WRITE );

@Test
@TestForIssue( jiraKey = "HHH-13175")
public void testSubsequentSelectFromFind() {
  inTransaction(
      entityManagerFactory(),
      session -> {
        final RootGraph<Issue> graph = GraphParser.parse( Issue.class, "comments", session );
        final Issue issue = session.find(
            Issue.class,
            1,
            Collections.singletonMap( GraphSemantic.FETCH.getJpaHintName(), graph )
        );
        assertTrue( Hibernate.isInitialized( issue ) );
        assertTrue( Hibernate.isInitialized( issue.getComments() ) );
        assertTrue( Hibernate.isInitialized( issue.getReporter() ) );
        assertTrue( Hibernate.isInitialized( issue.getAssignee() ) );
        assertFalse( Hibernate.isInitialized( issue.getAssignee().getAssignedIssues() ) );
      }
  );
}

sessionFactory,
session -> {
  AnotherEntity it = session.find( AnotherEntity.class, 1 );
  assertNotNull( it );

sessionFactory,
session -> {
  TheEntity it = session.find( TheEntity.class, 1 );
  assertNotNull( it );

sessionFactory,
session -> {
  TheEntity it = session.find( TheEntity.class, 1 );
  assertNotNull( it );

@Override
public <T> T find(Class<T> entityClass, Object primaryKey) {
  return delegate.find( entityClass, primaryKey );
}

@Override
public <T> T find(Class<T> entityClass, Object primaryKey, LockModeType lockMode) {
  return delegate.find( entityClass, primaryKey, lockMode );
}

@Override
public <T> T find(Class<T> entityClass, Object primaryKey, LockModeType lockMode, Map<String, Object> properties) {
  return delegate.find( entityClass, primaryKey, lockMode, properties );
}

@Override
public <T> T find(Class<T> entityClass, Object primaryKey, Map<String, Object> properties) {
  return delegate.find( entityClass, primaryKey, properties );
}

sessionFactory,
session -> {
  TheEntity it = session.find( TheEntity.class, 1 );
  assertNotNull( it );

sessionFactory,
session -> {
  TheEntity it = session.find( TheEntity.class, 1 );
  assertNotNull( it );