/** * @delegate Do not change semantics here. * @see javax.persistence.EntityTransaction#begin() */ @Override public void begin() throws RecoverablePersistenceException { try { this.txState.begin(); } catch (final RecoverablePersistenceException ex) { PersistenceExceptions.throwFiltered(ex); removeTransaction(this); } catch (final RuntimeException ex) { PersistenceExceptions.throwFiltered(ex); removeTransaction(this); throw ex; } }
TransactionState(final String ctx) { this.startTime = System.currentTimeMillis(); this.txUuid = String.format("%s:%s", ctx, UUID.randomUUID().toString()); this.stopWatch = new StopWatch(); this.stopWatch.start(); this.owner = Logs.isExtrrreeeme() ? Threads.currentStackString() : "n/a"; try { this.eventLog(TxStep.BEGIN, TxEvent.CREATE); final EntityManagerFactory anemf = (EntityManagerFactoryImpl) PersistenceContexts.getEntityManagerFactory(ctx); checkParam(anemf, notNullValue()); this.em = anemf.createEntityManager(); checkParam(this.em, notNullValue()); this.transaction = this.em.getTransaction(); this.transaction.begin(); this.session = new WeakReference<Session>((Session) this.em.getDelegate()); this.eventLog(TxStep.END, TxEvent.CREATE); } catch (final Throwable ex) { Logs.exhaust().error(ex, ex); this.eventLog(TxStep.FAIL, TxEvent.CREATE); this.rollback(); throw new RuntimeException(PersistenceExceptions.throwFiltered(ex)); } finally { outstanding.put(this.txUuid, this); } }
/** * Invokes underlying merge implementation per jsr-220 * * @param object The object to merge * @param <T> The return type * @return The persistent instance for the object */ public static <T> T mergeDirect(final T object) { try { return getTransaction(object).getTxState().getEntityManager().merge(object); } catch (final RuntimeException ex) { PersistenceExceptions.throwFiltered(ex); throw ex; } }
/** * * * <table> * <tbody> * <tr valign="top"> * <th>Scenario</th> * <th><tt>EntityManager.persist</tt></th> * <th><tt>EntityManager.merge</tt></th> * <th><tt>SessionManager.saveOrUpdate</tt></th> * </tr> * <tr valign="top"> * <th>Object passed was never persisted</th> * * <td>1. Object added to persistence context as new entity<br> * 2. New entity inserted into database at flush/commit</td> * <td>1. State copied to new entity.<br> * 2. New entity added to persistence context<br> * 3. New entity inserted into database at flush/commit<br> * 4. New entity returned</td> * <td>1. Object added to persistence context as new entity<br> * 2. New entity inserted into database at flush/commit</td> * </tr> * <tr valign="top"> * <th>Object was previously persisted, but not loaded in this persistence context</th> * <td>1. <tt>EntityExistsException</tt> thrown (or a <tt>PersistenceException</tt> at * flush/commit)</td> * * <td>2. Existing entity loaded.<br> * 2. State copied from object to loaded entity<br> * 3. Loaded entity updated in database at flush/commit<br> * 4. Loaded entity returned</td> * <td>1. Object added to persistence context<br> * 2. Loaded entity updated in database at flush/commit</td> * </tr> * <tr valign="top"> * <th>Object was previously persisted and already loaded in this persistence context</th> * <td>1. <tt>EntityExistsException</tt> thrown (or a <tt>PersistenceException</tt> at flush or * commit time)</td> * * <td>1. State from object copied to loaded entity<br> * 2. Loaded entity updated in database at flush/commit<br> * 3. Loaded entity returned</td> * <td>1. <tt>NonUniqueObjectException</tt> thrown</td> * </tr> * </tbody> * </table> * * @param newObject */ public <T> T merge(final T newObject) { try { return this.getEntityManager().merge(newObject); } catch (final RuntimeException ex) { PersistenceExceptions.throwFiltered(ex); throw ex; } }
public static <T> void refresh(final T newObject, final LockModeType lockMode) throws ConstraintViolationException { try { getTransaction(newObject).getTxState().getEntityManager().refresh(newObject, lockMode); } catch (final RuntimeException ex) { PersistenceExceptions.throwFiltered(ex); throw ex; } }
/** * Invokes underlying persist implementation per jsr-220 * * @throws ConstraintViolationException * @see http://opensource.atlassian.com/projects/hibernate/browse/HHH-1273 * @param newObject * @return */ public static <T> T persist(final T newObject) throws ConstraintViolationException { try { getTransaction(newObject).getTxState().getEntityManager().persist(newObject); return newObject; } catch (final RuntimeException ex) { PersistenceExceptions.throwFiltered(ex); throw ex; } }
/** * Invokes underlying persist implementation per jsr-220 * * @see http://opensource.atlassian.com/projects/hibernate/browse/HHH-1273 * @param newObject * @return */ public <T> T persist(final T newObject) { try { this.getEntityManager().persist(newObject); return newObject; } catch (final RuntimeException ex) { PersistenceExceptions.throwFiltered(ex); throw ex; } }
private void doRollback() { try { if ((this.transaction != null) && this.transaction.isActive()) { this.transaction.rollback(); } } catch (final Throwable e) { PersistenceExceptions.throwFiltered(e); } finally { this.doCleanup(); } }
/** * @delegate Do not change semantics here. * @see javax.persistence.EntityTransaction#commit() */ @Override public void commit() throws RecoverablePersistenceException { removeTransaction(this); if ((this.txState != null) && this.txState.isActive()) { try { this.txState.commit(); } catch (final RuntimeException ex) { throw PersistenceExceptions.throwFiltered(ex); } } else { Logs.extreme().error("Duplicate call to commit( ): " + Threads.currentStackString()); } }
/** * Private for a reason. * * @see {@link CascadingTx#get(Class)} * @param persistenceContext * @throws RecoverablePersistenceException */ @SuppressWarnings("unchecked") CascadingTx(final String ctx) throws RecoverablePersistenceException { final StackTraceElement ste = Threads.currentStackFrame(4); final String uuid = UUID.randomUUID().toString(); this.record = new TxRecord(ctx, uuid, ste); try { this.txState = new TxState(ctx); } catch (final RuntimeException ex) { Logs.extreme().error(ex, ex); this.rollback(); throw PersistenceExceptions.throwFiltered(ex); } }
/** * @see EntityWrapper#merge(Object) * @param newObject * @throws PersistenceException */ public <T> T mergeAndCommit(T newObject) { try { newObject = this.getEntityManager().merge(newObject); this.commit(); return newObject; } catch (final RuntimeException ex) { try { PersistenceExceptions.throwFiltered(ex); throw ex; } finally { this.rollback(); } } }
@Override public void commit() { this.eventLog(TxStep.BEGIN, TxEvent.COMMIT); try { this.transaction.commit(); this.eventLog(TxStep.END, TxEvent.COMMIT); } catch (final RuntimeException e) { this.rollback(); this.eventLog(TxStep.FAIL, TxEvent.COMMIT); PersistenceExceptions.throwFiltered(e); throw e; } finally { this.cleanup(); } }
@Override public void rollback() { this.eventLog(TxStep.BEGIN, TxEvent.ROLLBACK); try { if ((this.transaction != null) && this.transaction.isActive()) { this.transaction.rollback(); } this.eventLog(TxStep.END, TxEvent.ROLLBACK); } catch (final Throwable e) { this.eventLog(TxStep.FAIL, TxEvent.ROLLBACK); PersistenceExceptions.throwFiltered(e); } finally { this.cleanup(); } }
/** * * * <table> * <tbody> * <tr valign="top"> * <th>Scenario</th> * <th><tt>EntityManager.persist</tt></th> * <th><tt>EntityManager.merge</tt></th> * <th><tt>SessionManager.saveOrUpdate</tt></th> * </tr> * <tr valign="top"> * <th>Object passed was never persisted</th> * * <td>1. Object added to persistence context as new entity<br> * 2. New entity inserted into database at flush/commit</td> * <td>1. State copied to new entity.<br> * 2. New entity added to persistence context<br> * 3. New entity inserted into database at flush/commit<br> * 4. New entity returned</td> * <td>1. Object added to persistence context as new entity<br> * 2. New entity inserted into database at flush/commit</td> * </tr> * <tr valign="top"> * <th>Object was previously persisted, but not loaded in this persistence context</th> * <td>1. <tt>EntityExistsException</tt> thrown (or a <tt>PersistenceException</tt> at * flush/commit)</td> * * <td>2. Existing entity loaded.<br> * 2. State copied from object to loaded entity<br> * 3. Loaded entity updated in database at flush/commit<br> * 4. Loaded entity returned</td> * <td>1. Object added to persistence context<br> * 2. Loaded entity updated in database at flush/commit</td> * </tr> * <tr valign="top"> * <th>Object was previously persisted and already loaded in this persistence context</th> * <td>1. <tt>EntityExistsException</tt> thrown (or a <tt>PersistenceException</tt> at flush or * commit time)</td> * * <td>1. State from object copied to loaded entity<br> * 2. Loaded entity updated in database at flush/commit<br> * 3. Loaded entity returned</td> * <td>1. <tt>NonUniqueObjectException</tt> thrown</td> * </tr> * </tbody> * </table> * * @throws ConstraintViolationException * @param newObject * @throws NoSuchElementException * @throws TransactionException */ public static <T> T merge(final T newObject) throws ConstraintViolationException { if (!isPersistent(newObject)) { try { return uniqueResult(newObject); } catch (final Exception ex) { return persist(newObject); } } else { try { final T persistedObject = getTransaction(newObject).getTxState().getEntityManager().merge(newObject); return persistedObject == newObject ? newObject : persistedObject; } catch (final RuntimeException ex) { PersistenceExceptions.throwFiltered(ex); throw ex; } } }
public static <T> T uniqueResult(final T example) throws TransactionException, NoSuchElementException { try { final Object pk = resolvePrimaryKey(example); final String natId = resolveNaturalId(example); if (pk != null) { return maybePrimaryKey(example); } else if (natId != null) { return maybeNaturalId(example); } else { return maybeDefinitelyExample(example); } } catch (final NoSuchElementException ex) { throw ex; } catch (final RuntimeException ex) { Logs.extreme().trace(ex, ex); final Exception newEx = PersistenceExceptions.throwFiltered(ex); throw new TransactionInternalException(newEx.getMessage(), newEx); } }
/** * Returns the unique result from the database that exactly matches <code>example</code>. The * differences between this method and {@link #getUnique(Object)} are: * * <ol> * <li>{@link #getUnique(Object)} uses <i><code>enableLike</code></i> match and this method does * not. <i><code>enableLike</code></i> criteria trips hibernate when special characters are * involved. So it has been replaced by exact "=" (equals to) * <li>Unique result logic is correctly implemented in this method. If the query returns more * than one result, this method correctly throws an exception wrapping <code> * NonUniqueResultException</code>. {@link #getUnique(Object)} does not throw an exception * in this case and returns a result as long as it finds one or more matching results * (because of the following properties set on the query: <code>setMaxResults(1)</code>, * <code>setFetchSize(1)</code> and <code>setFirstResult(0)</code>) * </ol> * * @param example * @return * @throws EucalyptusCloudException */ @SuppressWarnings("unchecked") public <T> T getUniqueEscape(final T example) throws EucalyptusCloudException { try { Object id = null; try { id = this.getEntityManager() .getEntityManagerFactory() .getPersistenceUnitUtil() .getIdentifier(example); } catch (final Exception ex) { } if (id != null) { final T res = (T) this.getEntityManager().find(example.getClass(), id); if (res == null) { throw new NoSuchElementException("@Id: " + id); } else { return res; } } else if ((example instanceof HasNaturalId) && (((HasNaturalId) example).getNaturalId() != null)) { final String natId = ((HasNaturalId) example).getNaturalId(); final T ret = (T) this.createCriteria(example.getClass()) .setLockMode(LockMode.NONE) .setCacheable(true) .add(Restrictions.naturalId().set("naturalId", natId)) .uniqueResult(); if (ret == null) { throw new NoSuchElementException("@NaturalId: " + natId); } return ret; } else { final T ret = (T) this.createCriteria(example.getClass()) .setLockMode(LockMode.NONE) .setCacheable(true) .add(Example.create(example)) .uniqueResult(); if (ret == null) { throw new NoSuchElementException("example: " + LogUtil.dumpObject(example)); } return ret; } } catch (final NonUniqueResultException ex) { throw new EucalyptusCloudException( "Get unique failed for " + example.getClass().getSimpleName() + " because " + ex.getMessage(), ex); } catch (final NoSuchElementException ex) { throw new EucalyptusCloudException( "Get unique failed for " + example.getClass().getSimpleName() + " using " + ex.getMessage(), ex); } catch (final Exception ex) { final Exception newEx = PersistenceExceptions.throwFiltered(ex); throw new EucalyptusCloudException( "Get unique failed for " + example.getClass().getSimpleName() + " because " + newEx.getMessage(), newEx); } }