public Object beginTransaction(EntityManager entityManager,
    TransactionDefinition definition) throws TransactionException, SQLException, PersistenceException 
{
		if (definition.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT) {
			throw new InvalidIsolationLevelException(
					"Standard JPA does not support custom isolation levels - " +
					"use a special JpaDialect for your JPA implementation");
		}
		entityManager.getTransaction().begin();
		return null;
}

This implementation invokes the standard JPA Transaction.begin method. Throws an InvalidIsolationLevelException if a non-default isolation level is set.

This implementation does not return any transaction data Object, since there is no state to be kept for a standard JPA transaction. Hence, subclasses do not have to care about the return value (null) of this implementation and are free to return their own transaction data Object.

 public  void cleanupTransaction(Object transactionData) 
{

}

This implementation does nothing, since the default beginTransaction implementation does not require any cleanup.

 public EntityManagerFactoryPlusOperations getEntityManagerFactoryPlusOperations(EntityManagerFactory rawEntityManager) 
{
		throw new UnsupportedOperationException(getClass().getName() + " does not support EntityManagerFactoryPlusOperations");
}

 public EntityManagerPlusOperations getEntityManagerPlusOperations(EntityManager rawEntityManager) 
{
		throw new UnsupportedOperationException(getClass().getName() + " does not support EntityManagerPlusOperations");
}

 public ConnectionHandle getJdbcConnection(EntityManager entityManager,
    boolean readOnly) throws SQLException, PersistenceException 
{
		return null;
}

This implementation always returns null, indicating that no JDBC Connection can be provided.

 public Object prepareTransaction(EntityManager entityManager,
    boolean readOnly,
    String name) throws PersistenceException 
{
		return null;
}

 public  void releaseJdbcConnection(ConnectionHandle conHandle,
    EntityManager em) throws SQLException, PersistenceException 
{

}

This implementation does nothing, assuming that the Connection will implicitly be closed with the EntityManager.

If the JPA implementation returns a Connection handle that it expects the application to close after use, the dialect implementation needs to invoke Connection.close() (or some other method with similar effect) here.

 public boolean supportsEntityManagerFactoryPlusOperations() 
{
		return false;
}

 public boolean supportsEntityManagerPlusOperations() 
{
		return false;
}

 public DataAccessException translateExceptionIfPossible(RuntimeException ex) 
{
		return EntityManagerFactoryUtils.convertJpaAccessExceptionIfPossible(ex);
}

This implementation delegates to EntityManagerFactoryUtils.