import org.hibernate.jdbc.ReturningWork; //导入依赖的package包/类
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);
			}
		}
	}));
}
 

import org.hibernate.jdbc.ReturningWork; //导入依赖的package包/类
@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 );
}
 

import org.hibernate.jdbc.ReturningWork; //导入依赖的package包/类
@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);
        }
    });
}
 

import org.hibernate.jdbc.ReturningWork; //导入依赖的package包/类
@Override
public <T> T doReturningWork(ReturningWork<T> work) throws HibernateException {
	return session.doReturningWork( work );
}
 

import org.hibernate.jdbc.ReturningWork; //导入依赖的package包/类
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();
}
 

import org.hibernate.jdbc.ReturningWork; //导入依赖的package包/类
protected <T> T doReturningWork(ReturningWork<T> work) throws HibernateException {
    return this.getSession().doReturningWork(work);
}
 

import org.hibernate.jdbc.ReturningWork; //导入依赖的package包/类
protected <T> T doDatabaseReturningWork(ReturningWork<T> work) {
	return em.unwrap(Session.class).doReturningWork(work);
}
 

import org.hibernate.jdbc.ReturningWork; //导入依赖的package包/类
/**
 * 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;