/** * Method to transition when serialised. * @param op ObjectProvider * @return The new LifeCycle state */ public LifeCycleState transitionSerialize(ObjectProvider op) { Transaction tx = op.getExecutionContext().getTransaction(); if (tx.isActive() && !tx.getOptimistic()) { return changeState(op, P_CLEAN); } return this; }
/** * Called by PMF under required synchronization */ protected void internalBegin() { tx.begin(); }
public void commit() { tx.commit(); }
/** * Mutator for the rollback-only setting */ public void setRollbackOnly() { if (tx.isActive()) { // Only apply to active transactions tx.setRollbackOnly(); } }
private static LDAPTransactionEventListener getTransactionEventListener(ExecutionContext ec) { Transaction transaction = ec.getTransaction(); Map<String, Object> txOptions = transaction.getOptions(); LDAPTransactionEventListener listener = (txOptions != null ? (LDAPTransactionEventListener)txOptions.get("LDAPTransactionEventListener") : null); if (listener == null) { listener = new LDAPTransactionEventListener(ec); transaction.setOption("LDAPTransactionEventListener", listener); transaction.addTransactionEventListener(listener); } return listener; }
/** * Method to assert if the current transaction is active or non transactional writes are allowed. * Throws a TransactionNotWritableException if not active and non transactional writes are disabled */ protected void assertWritable() { if (!ec.getTransaction().isActive() && !ec.getTransaction().getNontransactionalWrite()) { throw new TransactionNotWritableException(); } }
/** * Method to transition to read-field state. * @param sm StateManager. * @param isLoaded if the field was previously loaded * @return new LifeCycle state. */ public LifeCycleState transitionReadField(StateManager sm, boolean isLoaded) { Transaction tx = sm.getObjectManager().getTransaction(); if (!tx.isActive() && !tx.getNontransactionalRead()) { throw new NucleusUserException(LOCALISER.msg("027000"), sm.getInternalObjectId()); } if (!tx.getOptimistic() && tx.isActive()) { return changeState(sm, P_CLEAN); } else { return changeState(sm, P_NONTRANS); } }
/** * Accessor for whether the transaction is active * @return Whether it is active */ public boolean isActive() { return tx.isActive(); }
/** * Mutator for the isolation level. * @param level The level * @throws JDOUserException if the required level is not supported. */ public void setIsolationLevel(String level) { assertNotCommitting(); if (tx.isActive() && !tx.getOptimistic()) { throw new JDOUnsupportedOptionException("Cannot change the transaction isolation level while a datastore transaction is active"); } PersistenceManagerFactory pmf = pm.getPersistenceManagerFactory(); if (!pmf.supportedOptions().contains("javax.jdo.option.TransactionIsolationLevel." + level)) { throw new JDOUnsupportedOptionException("Isolation level \"" + level + "\" not supported by this datastore"); } int isolationLevel = TransactionUtils.getTransactionIsolationLevelForName(level); tx.setOption(org.datanucleus.Transaction.TRANSACTION_ISOLATION_OPTION, isolationLevel); }
/** * Method to assert if no active transaction and nontransactionalRead is not set. * Throws JDOUserException if the tx is not active and no non-transactional read is available * @param operation The operation */ protected void assertReadable(String operation) { if (!ec.getTransaction().isActive() && !ec.getTransaction().getNontransactionalRead()) { throw new JDOUserException(Localiser.msg("011001", operation)); } }
/** * Accessor for restoreValues setting * @return The setting for restoreValues */ public boolean getRestoreValues() { return tx.getRestoreValues(); }
/** * Convenience accessor for setting a transaction option. * @param option option name * @param value The value */ public void setOption(String option, String value) { tx.setOption(option, value); }
/** * Accessor for retainValues setting * @return The setting for retainValues */ public boolean getRetainValues() { return tx.getRetainValues(); }
if (om.getTransaction().getRollbackOnly()) om.getTransaction().commit();
/** * Method to transition to rollback state. * @param op ObjectProvider. * @param tx The transaction * @return new LifeCycle state. **/ public LifeCycleState transitionRollback(ObjectProvider op, Transaction tx) { if (tx.getRetainValues()) { if (tx.getRestoreValues()) { op.restoreFields(); } return changeState(op, P_NONTRANS); } op.clearNonPrimaryKeyFields(); op.clearSavedFields(); return changeState(op, HOLLOW); }
/** * Accessor for optimistic setting * @return The setting for optimistic */ public boolean getOptimistic() { return tx.getOptimistic(); }
public void rollback() { tx.rollback(); }
/** * Accessor for nontransactionalWrite setting * @return The setting for nontransactionalWrite */ public boolean getNontransactionalWrite() { return tx.getNontransactionalWrite(); }
/** * Accessor for nontransactionalRead setting * @return The setting for nontransactionalRead */ public boolean getNontransactionalRead() { return tx.getNontransactionalRead(); }
/** * Method to transition to read-field state. * @param sm StateManager. * @param isLoaded if the field was previously loaded * @return new LifeCycle state. */ public LifeCycleState transitionReadField(StateManager sm, boolean isLoaded) { Transaction tx = sm.getObjectManager().getTransaction(); if (!tx.isActive() && !tx.getNontransactionalRead()) { throw new NucleusUserException(LOCALISER.msg("027001"), sm.getInternalObjectId()); } if (!tx.getOptimistic() && tx.isActive()) { return changeState(sm, P_CLEAN); } else { return changeState(sm, P_NONTRANS); } }