Java 类org.hibernate.jdbc.ReturningWork 实例源码

private void assertRowCount(JpaHibernateContentPersistenceService tested, String dcpContentType, int expectedCount) {
    final String tablename = tested.getTableName(dcpContentType);
    Assert.assertEquals((Integer) expectedCount, tested.doDatabaseReturningWork(new ReturningWork<Integer>() {

        @Override
        public Integer execute(Connection conn) throws SQLException {
            PreparedStatement ps = null;
            ResultSet rs = null;
            try {
                ps = conn.prepareStatement("select count(*) from " + tablename);
                rs = ps.executeQuery();
                if (rs.next()) {
                    return rs.getInt(1);
                }
                return 0;
            } finally {
                JpaHibernateContentPersistenceService.closeJDBCStuff(ps, rs);
            }
        }
    }));
}

@Override
public <T> T doReturningWork(final ReturningWork<T> work) throws HibernateException {
    WorkExecutorVisitable<T> realWork = new WorkExecutorVisitable<T>() {
        @Override
        public T accept(WorkExecutor<T> workExecutor, Connection connection) throws SQLException {
            return workExecutor.executeReturningWork( work, connection );
        }
    };
    return doWork( realWork );
}

@Override
public <R> R exec(EntityManager entityManager, final Function<Connection, R> work) {
    Session session = entityManager.unwrap(Session.class);
    return session.doReturningWork(new ReturningWork<R>() {

        @Override
        public R execute(Connection connection) throws SQLException {
            return work.apply(connection);
        }
    });
}

@Override
public <R> R exec(EntityManager entityManager, final Function<Connection, R> work) {
    Session session = entityManager.unwrap(Session.class);
    return session.doReturningWork(new ReturningWork<R>() {

        @Override
        public R execute(Connection connection) throws SQLException {
            return work.apply(connection);
        }
    });
}

@Override
public <T> T doReturningWork(ReturningWork<T> work) throws HibernateException {
    return session.doReturningWork( work );
}

private void clearDatabase() throws SQLException
{
    CommitCounter.versionedThing.get().reset();

    EntityManager em = getEntityManager();
    em.clear();
    EntityTransaction transaction = em.getTransaction();
    if (!transaction.isActive())
    {
        transaction.begin();
    }

    final Connection c;

    if (concreteJpaProviderTestModuleClass == HibernateJpaTestModule.class)
    {
        //  Hibernate cannot unwrap JDBC connection directly
        c = em.unwrap(Session.class).doReturningWork(new ReturningWork<Connection>()
        {
            @Override
            public Connection execute(Connection connection) throws SQLException
            {
                return connection;
            }
        });
    }
    else
    {
        c = em.unwrap(Connection.class);
    }

    Statement s = c.createStatement();
    s.execute("SET REFERENTIAL_INTEGRITY FALSE");
    Set<String> tables = new HashSet<String>();
    ResultSet rs = s.executeQuery("select table_name " + "from INFORMATION_SCHEMA.tables "
            + "where table_type='TABLE' and table_schema='PUBLIC'");
    while (rs.next())
    {
        // if we don't skip over the sequence table, we'll start getting "The sequence table information is not complete"
        // exceptions
        if (!rs.getString(1).startsWith("DUAL_") && !rs.getString(1).equals("SEQUENCE"))
        {
            tables.add(rs.getString(1));
        }
    }
    rs.close();
    for (String table : tables)
    {
        s.executeUpdate("DELETE FROM " + table);
    }
    transaction.commit();
    s.execute("SET REFERENTIAL_INTEGRITY TRUE");
    s.close();
}

protected <T> T doReturningWork(ReturningWork<T> work) throws HibernateException {
    return this.getSession().doReturningWork(work);
}

protected <T> T doDatabaseReturningWork(ReturningWork<T> work) {
    return em.unwrap(Session.class).doReturningWork(work);
}

/**
 * Controller for allowing users to perform JDBC related work using the Connection managed by this Session.  After
 * execution returns the result of the {@link ReturningWork#execute} call.
 *
 * @param work The work to be performed.
 * @param <T> The type of the result returned from the work
 *
 * @return the result from calling {@link ReturningWork#execute}.
 *
 * @throws HibernateException Generally indicates wrapped {@link java.sql.SQLException}
 */
public <T> T doReturningWork(ReturningWork<T> work) throws HibernateException;