How to use

getJdbcCoordinator

method

in

org.hibernate.engine.spi.SessionImplementor

@Override
public JdbcCoordinator getJdbcCoordinator() {
  return delegate.getJdbcCoordinator();
}

/**
 * Return whether the given Hibernate Session will always hold the same
 * JDBC Connection. This is used to check whether the transaction manager
 * can safely prepare and clean up the JDBC Connection used for a transaction.
 * <p>The default implementation checks the Session's connection release mode
 * to be "on_close".
 * @param session the Hibernate Session to check
 * @see ConnectionReleaseMode#ON_CLOSE
 */
@SuppressWarnings("deprecation")
protected boolean isSameConnectionForEntireSession(Session session) {
  if (!(session instanceof SessionImplementor)) {
    // The best we can do is to assume we're safe.
    return true;
  }
  ConnectionReleaseMode releaseMode =
      ((SessionImplementor) session).getJdbcCoordinator().getConnectionReleaseMode();
  return ConnectionReleaseMode.ON_CLOSE.equals(releaseMode);
}

/**
 * Determine whether the given Session is (still) physically connected
 * to the database, that is, holds an active JDBC Connection internally.
 * @param session the Hibernate Session to check
 * @see #isSameConnectionForEntireSession(Session)
 */
protected boolean isPhysicallyConnected(Session session) {
  if (!(session instanceof SessionImplementor)) {
    // The best we can do is to check whether we're logically connected.
    return session.isConnected();
  }
  return ((SessionImplementor) session).getJdbcCoordinator().getLogicalConnection().isPhysicallyConnected();
}

/**
 * Return whether the given Hibernate Session will always hold the same
 * JDBC Connection. This is used to check whether the transaction manager
 * can safely prepare and clean up the JDBC Connection used for a transaction.
 * <p>The default implementation checks the Session's connection release mode
 * to be "on_close".
 * @param session the Hibernate Session to check
 * @see ConnectionReleaseMode#ON_CLOSE
 */
@SuppressWarnings("deprecation")
protected boolean isSameConnectionForEntireSession(Session session) {
  if (!(session instanceof SessionImplementor)) {
    // The best we can do is to assume we're safe.
    return true;
  }
  ConnectionReleaseMode releaseMode =
      ((SessionImplementor) session).getJdbcCoordinator().getConnectionReleaseMode();
  return ConnectionReleaseMode.ON_CLOSE.equals(releaseMode);
}

/**
 * Determine whether the given Session is (still) physically connected
 * to the database, that is, holds an active JDBC Connection internally.
 * @param session the Hibernate Session to check
 * @see #isSameConnectionForEntireSession(Session)
 */
protected boolean isPhysicallyConnected(Session session) {
  if (!(session instanceof SessionImplementor)) {
    // The best we can do is to check whether we're logically connected.
    return session.isConnected();
  }
  return ((SessionImplementor) session).getJdbcCoordinator().getLogicalConnection().isPhysicallyConnected();
}

  @Override
  public void execute(Connection connection) throws SQLException {
    Statement stmt = ((SessionImplementor)s).getJdbcCoordinator().getStatementPreparer().createStatement();
    ((SessionImplementor)s).getJdbcCoordinator().getResultSetReturn().executeUpdate( stmt, "DROP FUNCTION spLock FROM TestInterSystemsFunctionsClass" );
  }
}

  public void execute(Connection connection) throws SQLException {
    Statement st = s.getJdbcCoordinator().getStatementPreparer().createStatement();
    s.getJdbcCoordinator().getResultSetReturn().extract( st, "SELECT COUNT(*) FROM " + table );
    ResultSet result = s.getJdbcCoordinator().getResultSetReturn().extract( st, "SELECT COUNT(*) FROM " + table );
    result.next();
    int rowCount = result.getInt( 1 );
    assertEquals( "Unexpected row count", expectedRowCount, rowCount );
  }
}

  private void releaseStatement(Session session, PreparedStatement ps) {
    if ( ps != null ) {
      try {
        ( (SessionImplementor) session ).getJdbcCoordinator().getResourceRegistry().release( ps );
      }
      catch ( Throwable ignore ) {
        // ignore...
      }
    }
  }
}

  @Override
  public void execute(Connection connection) throws SQLException {
    PreparedStatement statement = ((SessionImplementor)s).getJdbcCoordinator().getStatementPreparer().prepareStatement( "SELECT * FROM STRANGE_TYPED_OBJECT WHERE ID=?" );
    statement.setInt(1, id.intValue());
    ResultSet resultSet = ((SessionImplementor)s).getJdbcCoordinator().getResultSetReturn().extract( statement );
    assertTrue("A row should have been returned", resultSet.next());
    assertTrue("Default value should have been mapped to null", resultSet.getObject("VALUE_ONE") == null);
    assertTrue("Default value should have been mapped to null", resultSet.getObject("VALUE_TWO") == null);
    assertEquals("Non-Default value should not be changed", resultSet.getInt("VALUE_THREE"), 5);
    assertTrue("Default value should have been mapped to null", resultSet.getObject("VALUE_FOUR") == null);
  }
}

  @Override
  public void execute(Connection connection) throws SQLException {
    PreparedStatement stmnt = null;
    try {
      stmnt = session.getJdbcCoordinator().getStatementPreparer().prepareStatement( "UPDATE T_JOB SET JOB_STATUS = 1" );
      session.getJdbcCoordinator().getResultSetReturn().executeUpdate( stmnt );
    }
    finally {
      if ( stmnt != null ) {
        try {
          session.getJdbcCoordinator().getResourceRegistry().release( stmnt );
        }
        catch( Throwable ignore ) {
        }
      }
    }
  }
}

  @Override
  public void execute(Connection connection) throws SQLException {
    // Attempt to insert some bad values into the T_MEMBERSHIP table that should
    // result in a constraint violation
    PreparedStatement ps = null;
    try {
      ps = ((SessionImplementor)session).getJdbcCoordinator().getStatementPreparer().prepareStatement( "INSERT INTO T_MEMBERSHIP (user_id, group_id) VALUES (?, ?)" );
      ps.setLong(1, 52134241);    // Non-existent user_id
      ps.setLong(2, 5342);        // Non-existent group_id
      ((SessionImplementor)session).getJdbcCoordinator().getResultSetReturn().executeUpdate( ps );
      fail("INSERT should have failed");
    }
    catch (ConstraintViolationException ignore) {
      // expected outcome
    }
    finally {
      releaseStatement( session, ps );
    }
  }
}

@Test
public void basicStreamTest() {
  Session session = openSession();
  session.getTransaction().begin();
  // mainly we want to make sure that closing the Stream releases the ScrollableResults too
  assertThat( ( (SessionImplementor) session ).getJdbcCoordinator().getLogicalConnection().getResourceRegistry().hasRegisteredResources(), is( false ) );
  final Stream<MyEntity> stream = session.createQuery( "from MyEntity", MyEntity.class ).stream();
  assertThat( ( (SessionImplementor) session ).getJdbcCoordinator().getLogicalConnection().getResourceRegistry().hasRegisteredResources(), is( true ) );
  stream.forEach( System.out::println );
  assertThat( ( (SessionImplementor) session ).getJdbcCoordinator().getLogicalConnection().getResourceRegistry().hasRegisteredResources(), is( true ) );
  stream.close();
  assertThat( ( (SessionImplementor) session ).getJdbcCoordinator().getLogicalConnection().getResourceRegistry().hasRegisteredResources(), is( false ) );
  session.getTransaction().commit();
  session.close();
}

  @Override
  public void execute(Connection connection) throws SQLException {
    Statement stmt = ( (SessionImplementor) s ).getJdbcCoordinator()
        .getStatementPreparer()
        .createStatement();
    String create_function = "CREATE FUNCTION SQLUser.TestInterSystemsFunctionsClass_spLock\n" +
        "     ( INOUT pHandle %SQLProcContext, \n" +
        "       ROWID INTEGER \n" +
        " )\n" +
        " FOR User.TestInterSystemsFunctionsClass " +
        "    PROCEDURE\n" +
        "    RETURNS INTEGER\n" +
        "    LANGUAGE OBJECTSCRIPT\n" +
        "    {\n" +
        "        q 0\n" +
        "     }";
    ( (SessionImplementor) s ).getJdbcCoordinator().getResultSetReturn().executeUpdate(
        stmt,
        create_function
    );
  }
}

  @Override
  public void execute(Connection connection) throws SQLException {
    // prepare/execute a query against a non-existent table
    PreparedStatement ps = null;
    try {
      ps = ((SessionImplementor)session).getJdbcCoordinator().getStatementPreparer().prepareStatement( "SELECT user_id, user_name FROM tbl_no_there" );
      ((SessionImplementor)session).getJdbcCoordinator().getResultSetReturn().extract( ps );
      fail("SQL compilation should have failed");
    }
    catch (SQLGrammarException ignored) {
      // expected outcome
    }
    finally {
      releaseStatement( session, ps );
    }
  }
}

private void validateColumn(Connection connection, String columnName, int expectedJdbcTypeCode)
    throws SQLException {
  DatabaseMetaData meta = connection.getMetaData();
  // DBs treat the meta information differently, in particular case sensitivity.
  // We need to use the meta information to find out how to treat names
  String tableNamePattern = generateFinalNamePattern( meta, SOME_ENTITY_TABLE_NAME );
  String columnNamePattern = generateFinalNamePattern( meta, columnName );
  ResultSet columnInfo = meta.getColumns( null, null, tableNamePattern, columnNamePattern );
  s.getJdbcCoordinator().getResourceRegistry().register(columnInfo, columnInfo.getStatement());
  assertTrue( columnInfo.next() );
  int dataType = columnInfo.getInt( "DATA_TYPE" );
  s.getJdbcCoordinator().getResourceRegistry().release( columnInfo, columnInfo.getStatement() );
  assertEquals(
      columnName,
      JdbcTypeNameMapper.getTypeName( expectedJdbcTypeCode ),
      JdbcTypeNameMapper.getTypeName( dataType )
  );
}

  @Override
  public void execute(Connection connection) throws SQLException {
    PreparedStatement ps = sessionImplementor.getJdbcCoordinator().getStatementPreparer().prepareStatement( QUERY_STRING );
    ResultSet rs = sessionImplementor.getJdbcCoordinator().getResultSetReturn().extract( ps );
    try {
      ResultSetMetaData metadata = rs.getMetaData();
      String column1Alias = getDialect().getColumnAliasExtractor().extractColumnAlias( metadata, 1 );
      String column2Alias = getDialect().getColumnAliasExtractor().extractColumnAlias( metadata, 2 );
      Assert.assertFalse( "bad dialect.getColumnAliasExtractor impl", column1Alias.equals( column2Alias ) );
    }
    finally {
      sessionImplementor.getJdbcCoordinator().getResourceRegistry().release( rs, ps );
      sessionImplementor.getJdbcCoordinator().getResourceRegistry().release( ps );
    }
  }
}

@Test
public void testExceptionHandling() {
  Session session = openSession();
  SessionImplementor sessionImpl = (SessionImplementor) session;
  boolean caught = false;
  try {
    PreparedStatement ps = sessionImpl.getJdbcCoordinator().getStatementPreparer()
        .prepareStatement( "select count(*) from NON_EXISTENT" );
    sessionImpl.getJdbcCoordinator().getResultSetReturn().execute( ps );
  }
  catch ( JDBCException ok ) {
    caught = true;
  }
  finally {
    session.close();
  }
  assertTrue( "The connection did not throw a JDBCException as expected", caught );
}

Field field = sessionImplementor.getJdbcCoordinator().getClass().getDeclaredField( "currentBatch" );
field.setAccessible( true );
Batch batch = (Batch) field.get( sessionImplementor.getJdbcCoordinator() );
if ( batch != null ) {

  @Override
  public void execute(Connection connection) throws SQLException {
    final JdbcCoordinator jdbcCoordinator = ( (SessionImplementor) session ).getJdbcCoordinator();
    final StatementPreparer statementPreparer = jdbcCoordinator.getStatementPreparer();
    final ResultSetReturn resultSetReturn = jdbcCoordinator.getResultSetReturn();
    PreparedStatement ps = null;
    try {
      ps = statementPreparer.prepareStatement( "UPDATE T_USER SET user_name = ? WHERE user_id = ?" );
      ps.setNull( 1, Types.VARCHAR ); // Attempt to update user name to NULL (NOT NULL constraint defined).
      ps.setLong( 2, user.getId() );
      resultSetReturn.executeUpdate( ps );
      fail( "UPDATE should have failed because of not NULL constraint." );
    }
    catch ( ConstraintViolationException ignore ) {
      // expected outcome
    }
    finally {
      releaseStatement( session, ps );
    }
  }
}

session.getJdbcCoordinator().executeBatch();