Examples of rollback()

• bitronix.tm.BitronixTransactionManager.rollback()
• br.gov.frameworkdemoiselle.exception.ApplicationException.rollback()
• br.gov.frameworkdemoiselle.transaction.Transaction.rollback()
  Roll back the transaction associated with the current thread. When this method completes, the thread is no longer associated with a transaction.
• co.paralleluniverse.galaxy.quasar.Store.rollback()
  Reverts {@code set} operations that were performed during the transactions.

  This method does not complete thetransaction. {@link #commit(co.paralleluniverse.galaxy.StoreTransaction) endTransaction()} must still be called. @param txn The current transaction.

• com.adito.jdbc.JDBCPreparedStatement.rollback()
• com.alibaba.druid.pool.DruidPooledConnection.rollback()
• com.alibaba.druid.pool.xa.JtdsXAResource.rollback()
• com.alibaba.otter.canal.store.memory.MemoryEventStoreWithBuffer.rollback()
• com.alu.e3.common.transaction.ITransaction.rollback()
• com.arjuna.ats.internal.jta.resources.jts.orbspecific.XAResourceRecord.rollback()
• com.arjuna.ats.internal.jta.transaction.arjunacore.TransactionManagerImple.rollback()
• com.arjuna.ats.internal.jta.transaction.arjunacore.jca.XATerminatorImple.rollback()
  Rollback the imported transaction subordinate. @param xid the transaction to roll back. @throws XAException thrown if there are any errors.
• com.arjuna.ats.internal.jta.transaction.jts.TransactionManagerImple.rollback()
• com.arjuna.ats.internal.jts.orbspecific.CurrentImple.rollback()
  If another thread has already terminated the transaction then: (i) if it rolled back, we do nothing - could throw TransactionRequired of INVALID_TRANSACTION, or NoTransaction. Probably not NoTransaction, since it would be better to distinguish between the situation where the transaction has already been terminated and there really is no transaction for this thread. (ii) if it committed, we throw INVALID_TRANSACTION.
• com.arjuna.ats.internal.jts.orbspecific.coordinator.ArjunaTransactionImple.rollback()
• com.arjuna.ats.internal.jts.orbspecific.interposition.coordinator.ServerTransaction.rollback()
• com.arjuna.ats.jts.extensions.AtomicTransaction.rollback()
• com.arjuna.mw.wst.UserTransaction.rollback()
  The rollback operation will terminate the transaction and return normally if it succeeded, while throwing an appropriate exception if it didn't. If there is no transaction associated with the invoking thread then WrongStateException is thrown. If the coordinator is not aware of the current transaction UnknownTransactionException is thrown. If any other error occurs a SystemException is thrown. When complete, this operation disassociates the transaction from the current thread such that it becomes associated with no transaction.
• com.arjuna.mw.wst11.UserTransaction.rollback()
  The rollback operation will terminate the transaction and return normally if it succeeded, while throwing an appropriate exception if it didn't. If there is no transaction associated with the invoking thread then WrongStateException is thrown. If the coordinator is not aware of the current transaction UnknownTransactionException is thrown. If any other error occurs a SystemException is thrown. When complete, this operation disassociates the transaction from the current thread such that it becomes associated with no transaction.
• com.arjuna.mw.wstx.UserTransaction.rollback()
  Abort the transaction. All participants that are still enlisted with the transaction are rolled back. @exception InvalidTransactionException Thrown if the current transaction is notknown about by the transaction system. @exception WrongStateException Thrown if the current transaction is not in astate that allows cancel to be called. @exception HeuristicHazardException Thrown if the participants generated a hazardheuristic. @exception HeuristicMixedException Thrown if the participants generated a mixed heuristic. @exception NoTransactionException Thrown if there is no transactionassociated with the invoking thread. @exception SystemException Thrown if some other error occurred.
• com.arjuna.webservices.wsat.ParticipantInboundEvents.rollback()
  Handle the rollback event. @param rollback The rollback notification. @param addressingContext The addressing context. @param arjunaContext The arjuna context.
• com.arjuna.webservices11.wsat.ParticipantInboundEvents.rollback()
  Handle the rollback event. @param rollback The rollback notification. @param addressingProperties The addressing context. @param arjunaContext The arjuna context.
• com.arjuna.wst.CompletionCoordinatorParticipant.rollback()
• com.arjuna.wst.stub.CompletionStub.rollback()
• com.arjuna.wst11.CompletionCoordinatorParticipant.rollback()
  Rollback. @param rollback The rollback notification. @param addressingProperties The addressing context. @param arjunaContext The arjuna context.
• com.arjuna.wst11.stub.CompletionStub.rollback()
• com.atomikos.icatch.CompositeTerminator.rollback()
  Rollback the current transaction. @exception IllegalStateException If prepared or inactive. @exception SysException If unexpected error.
• com.atomikos.icatch.Participant.rollback()
  Rollback of the participant's work. NOTE: custom participant implementations should preferably be made for the server's local VM (e.g., it is better not to do this over RMI). Also, they should rely on the icatch transaction manager for heuristic timeout (and NOT decide to terminate heuristically themselves). In that case, implementations never need to throw any of the heuristic exceptions of this method. @return HeuristicMessage[] An array of messages, null if none. @exception HeurCommitException If the participant committed. @exception HeurHazardException If the participant's final stateis unsure. @exception HeurMixedException If part of the work was rolled back. @exception SysException
• com.avaje.ebean.Transaction.rollback()
  Rollback the transaction.
• com.avaje.ebeaninternal.server.transaction.TransactionMap.State.rollback()
• com.caucho.db.xa.DbTransaction.rollback()
• com.caucho.db.xa.Transaction.rollback()
• com.ccbill.clessidra.interfaces.LimiterStrategy.rollback()
  Rollback this limiter strategy only @param methodGroup The group name of method group. @param invocationUUID The invocation UUID. @param args The arguments of the annotated method.
• com.cetsoft.imcache.cache.heap.tx.Transaction.rollback()
  Rollback the transaction.
• com.cloud.utils.db.Transaction.rollback()
• com.cloud.utils.db.TransactionLegacy.rollback()
• com.conexao.Transacao.rollback()
• com.db4o.ObjectContainer.rollback()
  rolls back the running transaction.
  
  Modified application objects im memory are not restored. Use combined calls to {@link #deactivate deactivate()}and {@link #activate activate()} to reload an objects member values. @throws Db4oIOException I/O operation failed or was unexpectedly interrupted. @throws DatabaseClosedException db4o database file was closed or failed to open. @throws DatabaseReadOnlyException database was configured as read-only.
• com.dci.intellij.dbn.connection.transaction.DatabaseTransactionManager.rollback()
• com.din.din.model.util.EntityCachingManager.rollback()
• com.dp.nebula.wormhole.common.interfaces.IWriterPeriphery.rollback()
• com.exedosoft.plat.Transaction.rollback()
• com.exedosoft.plat.agent.Task.rollBack()
• com.founder.fix.fixflow.core.ManagementService.rollBack()
  退回节点 @param taskId 操作的任务号 @param rollBackNodeId 退回的节点号 @param taskComment 处理意见 @param transientVariables 瞬态变量
• com.google.appengine.api.datastore.Transaction.rollback()
• com.google.walkaround.util.server.appengine.CheckedDatastore.CheckedTransaction.rollback()
• com.hazelcast.core.Transaction.rollback()
• com.j256.ormlite.support.DatabaseConnection.rollback()
  Roll back all changes since the savepoint was created. If savePoint is null then roll back all outstanding changes. @param savePoint That was returned by setSavePoint previously or null if none.
• com.jboss.transaction.txinterop.webservices.atinterop.generated.ParticipantPortType.rollback()
• com.jboss.transaction.wstf.webservices.sc007.generated.ParticipantPortType.rollback()
• com.jengine.orm.db.DBConnection.rollback()
• com.knowgate.jdc.JDCConnection.rollback()
• com.orientechnologies.orient.core.db.document.ODatabaseDocument.rollback()
• com.orientechnologies.orient.core.db.document.ODatabaseDocumentTx.rollback()
• com.orientechnologies.orient.core.db.record.ODatabaseFlat.rollback()
• com.orientechnologies.orient.core.db.record.ODatabaseRecord.rollback()
• com.orientechnologies.orient.object.db.OObjectDatabaseTx.rollback()
• com.orientechnologies.orient.server.tx.OTransactionOptimisticProxy.rollback()
• com.persistit.Transaction.rollback()

  Explicitly rolls back all work done within the scope of this transaction. If this transaction is not active, then this method throws an Exception. No further updates can be applied within the scope of this transaction.

  If called within the scope of a nested transaction, this method causes all enclosing transactions to roll back. This ensures that the outermost transaction will not commit if any inner transaction has rolled back.

  @throws PersistitIOException @throws IllegalStateException if there is no transaction scope or the current scope has already been committed.
• com.ponysdk.core.stm.Txn.rollback()
• com.skyline.energy.annotation.Transaction.rollback()
• com.sleepycat.je.XAEnvironment.rollback()
• com.sleepycat.je.recovery.RollbackTracker.Scanner.rollback()
• com.splout.db.qnode.QNodeHandler.rollback()
  Rollback: Set the version of some tablespaces to a particular one.

  Returns a {@link StatusMessage}.

• com.sun.enterprise.ee.synchronization.store.SynchronizationMemento.rollback()
  Rolls back to the previous saved state. @throws StoreException if an error while saving the state
• com.sun.enterprise.transaction.api.JavaEETransaction.rollback()
• com.sun.enterprise.transaction.api.JavaEETransactionManager.rollback()
• com.taobao.metamorphosis.client.producer.MessageProducer.rollback()
  �ع���ǰ�����������͵��κ���Ϣ���˷���������beginTransaction֮����� @throws MetaClientException @see #beginTransaction()
• com.taobao.metamorphosis.client.transaction.TransactionContext.rollback()
• com.taobao.metamorphosis.server.transaction.Transaction.rollback()
• com.thinkaurelius.titan.core.TitanGraph.rollback()
• com.thinkaurelius.titan.core.TitanTransaction.rollback()
  Aborts and closes the transaction. Will discard all modifications.

  The call releases data structures if possible. All element references (e.g. vertex objects) retrieved through this transaction are stale after the transaction closes and should no longer be used. @throws com.thinkaurelius.titan.diskstorage.StorageException if an error arises when releasing the transaction handle

• com.thinkaurelius.titan.diskstorage.keycolumnvalue.StoreTransaction.rollback()
• com.tinkerpop.blueprints.TransactionalGraph.rollback()
  Stop the current transaction and drop any mutations applied since the last transaction.
• com.tinkerpop.blueprints.impls.orient.OrientGraph.rollback()
• com.vaadin.data.util.sqlcontainer.SQLContainer.rollback()
  Rolls back all the changes, additions and removals made to the items of this container. @throws UnsupportedOperationException @throws SQLException
• com.youtube.vitess.vtgate.VtGate.rollback()
• dovetaildb.api.ApiService.rollback()
• hermes.store.MessageStore.rollback()
  Rollback the store. All messages added or removed since the last checkpoint/rollback will be rolled back. @throws JMSException @throws IOException
• in.partake.model.dao.PartakeConnection.rollback()
• io.fabric8.patch.Patch.rollback()
• java.sql.Connection.rollback()
  Rollback drops all changes made since the previous commit/rollback and releases any database locks currently held by the Connection. This method should only be used when auto commit has been disabled. @exception SQLException if a database-access error occurs. @see #setAutoCommit
• javax.ejb.ApplicationException.rollback()
• javax.jdo.Transaction.rollback()
  Roll back the current transaction. @throws JDOUserException if transactions are managed by a containerin the managed environment, or if the transaction is not active.
• javax.jms.QueueSession.rollback()
• javax.jms.Session.rollback()
• javax.jms.TopicSession.rollback()
• javax.jms.XASession.rollback()
• javax.persistence.EntityTransaction.rollback()
  Roll back the current transaction. @throws IllegalStateException if isActive() is false. @throws PersistenceException if an unexpected errorcondition is encountered.
• javax.resource.cci.LocalTransaction.rollback()
• javax.resource.spi.LocalTransaction.rollback()
• javax.resource.spi.XATerminator.rollback()
• javax.sql.rowset.JdbcRowSet.rollback()
  Each JdbcRowSet contains a Connection object from the original ResultSet or JDBC properties passed to it. Undoes all changes made in the current transaction and releases any database locks currently held by this Connection object. This method should be used only when auto-commit mode has been disabled. @throws SQLException if a database access error occurs or this Connectionobject within this JdbcRowSet is in auto-commit mode. @see #rollback(Savepoint)
• javax.transaction.Transaction.rollback()
• javax.transaction.TransactionManager.rollback()
• javax.transaction.UserTransaction.rollback()
  Rolls the transaction back
• javax.transaction.xa.XAResource.rollback()
• jdbm.RecordManager.rollback()
  Rollback (cancel) all changes since beginning of transaction.
• jodd.jtx.JtxTransaction.rollback()
  Roll back and completes current transaction. Transaction is rolled back on all attached resources. Resource are then detached from the transaction. When this method completes, transaction is no longer associated with current thread.
• liquibase.Liquibase.rollback()
• liquibase.changelog.ChangeSet.rollback()
• marauroa.server.db.TransactionPool.rollback()
  rolls this transaction back and frees the reservation @param dbtransaction transaction
• me.taylorkelly.bigbrother.datablock.BBDataBlock.rollback()
• mireka.pop.store.MaildropAppender.rollback()
  It closes the output stream if it is open, removes any temporary files and releases the appender. It does not add the mail to the maildrop.
• net.fortytwo.twitlogic.persistence.TweetStoreConnection.rollback()
• net.sf.ehcache.transaction.local.LocalTransactionContext.rollback()
  Rollback all work done in the context and release all registered soft locks
• net.sf.hibernate.Transaction.rollback()
• net.sf.xbus.base.core.TAManager.rollback()
  Performs a rollback for all actions on the registered resources and closes the resources.
• net.sf.xbus.technical.mq.MQConnection.rollback()
  Performs a rollback for all actions on the queues associated with this MQConnection (normally all queues of the current thread).
• net.sourceforge.squirrel_sql.fw.sql.ISQLConnection.rollback()
• net.timewalker.ffmq3.local.session.LocalSession.rollback()
• nexj.core.runtime.UnitOfWork.rollback()
  Rolls back the changes. @param bEndTx True to rollback also the distributed transaction.
• nexj.core.runtime.platform.generic.tx.GenericTransactionManager.rollback()
  @see javax.transaction.TransactionManager#rollback()
• org.activemq.service.Transaction.rollback()
• org.adbcj.Connection.rollback()
• org.apache.activemq.ActiveMQSession.rollback()
  Rolls back any messages done in this transaction and releases any locks currently held. @throws JMSException if the JMS provider fails to roll back thetransaction due to some internal error. @throws javax.jms.IllegalStateException if the method is not called by atransacted session.
• org.apache.activemq.broker.region.policy.DeadLetterStrategy.rollback()
  Allows for a Message that was already processed by a DLQ to be rolled back in case of a move or a retry of that message, otherwise the Message would be considered a duplicate if this strategy is doing Message Auditing. @param message
• org.apache.activemq.transaction.Transaction.rollback()
• org.apache.cayenne.access.Transaction.rollback()
• org.apache.cocoon.acting.ModularDatabaseAccess.OutputHelper.rollback()
  If a database transaction needs to rollback, this is called to inform the further processing logic about this fact. All already set attribute values are invalidated. This is difficult because only the request object can be used to synchronize this and build some kind of transaction object. Beaware that sending your data straight to some beans or other entities could result in data corruption!
• org.apache.cocoon.components.modules.output.OutputModule.rollback()
  If a database transaction needs to rollback, this is called to inform the further processing logic about this fact. All already set attribute values are invalidated. This is difficult because only the request object can be used to synchronize this and build some kind of transaction object. Beaware that sending your data straight to some beans or other entities could result in data corruption!
• org.apache.continuum.release.distributed.manager.DistributedReleaseManager.rollback()
• org.apache.derby.iapi.store.access.xa.XAResourceManager.rollback()
  rollback the transaction identified by Xid.

  The given transaction is roll'ed back and it's history is not maintained in the transaction table or long term log.

  @param cm The ContextManager returned from the find() call. @param xid A global transaction identifier. @exception StandardException Standard exception policy.

• org.apache.flume.Transaction.rollback()
  Indicates that the transaction can must be aborted. It is required that a transaction be in progress when this method is invoked.
• org.apache.flume.channel.file.FileChannel.FileBackedTransaction.rollback()
• org.apache.geronimo.transaction.BeanTransactionContext.rollback()
• org.apache.geronimo.transaction.context.BeanTransactionContext.rollback()
• org.apache.geronimo.transaction.context.ContainerTransactionContext.rollback()
• org.apache.geronimo.transaction.context.TransactionContext.rollback()
• org.apache.hadoop.hbase.regionserver.SplitTransaction.rollback()
  @param server Hosting server instance (May be null when testing). @param services @throws IOException If thrown, rollback failed. Take drastic action. @return True if we successfully rolled back, false if we got to the pointof no return and so now need to abort the server to minimize damage.
• org.apache.ibatis.session.SqlSession.rollback()
• org.apache.ibatis.transaction.Transaction.rollback()
• org.apache.jackrabbit.core.UserTransactionImpl.rollback()
  @see javax.transaction.UserTransaction#rollback
• org.apache.jackrabbit.data.core.TransactionContext.rollback()
  Rollback the transaction identified by this context. Rolls back changes on all resources. Throws exception at the end if errors were found. @throws XAException if an error occurs
• org.apache.jackrabbit.ocm.transaction.jackrabbit.UserTransactionImpl.rollback()
  @see javax.transaction.UserTransaction#rollback
• org.apache.jetspeed.components.persistence.store.Transaction.rollback()
• org.apache.juddi.datastore.DataStore.rollback()
  rollback transaction
• org.apache.juddi.util.jdbc.Transaction.rollback()
  rollback on all connections. This is not XA, but it could be one day.
• org.apache.lenya.cms.repository.Node.rollback()
  @param revisionNumber The revision number to roll back. @throws RepositoryException if this revision doesn't exist.
• org.apache.lucene.facet.taxonomy.directory.DirectoryTaxonomyWriter.rollback()
  Rollback changes to the taxonomy writer and closes the instance. Following this method the instance becomes unusable (calling any of its API methods will yield an {@link AlreadyClosedException}).
• org.apache.lucene.index.BlurIndexWriter.rollback()
• org.apache.lucene.index.IndexWriter.rollback()
  Close the IndexWriter without committing any changes that have occurred since the last commit (or since it was opened, if commit hasn't been called). This removes any temporary files that had been created, after which the state of the index will be the same as it was when commit() was last called or when this writer was first opened. This also clears a previous call to {@link #prepareCommit}. @throws IOException if there is a low-level IO error
• org.apache.marmotta.kiwi.reasoner.persistence.KiWiReasoningConnection.rollback()
• org.apache.marmotta.kiwi.sail.KiWiSailConnection.rollback()
• org.apache.marmotta.kiwi.versioning.persistence.KiWiVersioningConnection.rollback()
• org.apache.marmotta.ldcache.api.LDCachingConnection.rollback()
• org.apache.maven.archiva.transaction.CopyFileEvent.rollback()
• org.apache.maven.archiva.transaction.CreateFileEvent.rollback()
• org.apache.maven.continuum.release.ContinuumReleaseManager.rollback()
  Rollback changes made by a previous release. @param releaseId @param workingDirectory @param listener @throws ContinuumReleaseException
• org.apache.ode.store.ConfStoreConnection.rollback()
• org.apache.ojb.otm.core.Transaction.rollback()
  Rollback this transaction. A rollback on the transaction, notifies all its listeners. It, then initiates a rollback on all associated connections.
• org.apache.openjpa.kernel.Broker.rollback()
  Rollback the current transaction.
• org.apache.openjpa.persistence.OpenJPAEntityTransaction.rollback()
• org.apache.phoenix.hbase.index.covered.LocalTableState.rollback()
  Rollback all the given values from the underlying state. @param values
• org.apache.qpid.server.AMQChannel.rollback()
• org.apache.qpid.server.protocol.v0_8.AMQChannel.rollback()
• org.apache.qpid.server.txn.LocalTransaction.rollback()
• org.apache.qpid.server.txn.ServerTransaction.rollback()
  Rollback the transaction represented by this object. If the caller has registered one or more Actions, the onRollback() method on each will be executed immediately after the underlying transaction has rolled-back.
• org.apache.sandesha2.storage.Transaction.rollback()
• org.apache.solr.client.solrj.SolrServer.rollback()
  Performs a rollback of all non-committed documents pending.

  Note that this is not a true rollback as in databases. Content you have previously added may have been committed due to autoCommit, buffer full, other client performing a commit etc. @throws SolrServerException @throws IOException

• org.apache.sqoop.repository.RepositoryTransaction.rollback()
• org.apache.wookie.beans.util.IPersistenceManager.rollback()
  Rollback persistence manager transaction
• org.araneaframework.servlet.ServletAtomicResponseOutputExtension.rollback()
  Rollback the body of the response, not the headers. The buffer must not been commited.
• org.araneaframework.servlet.util.AtomicResponseHelper.rollback()
• org.axonframework.unitofwork.UnitOfWork.rollback()
  Clear the UnitOfWork of any buffered changes. All buffered events and registered aggregates are discarded and registered {@link org.axonframework.unitofwork.UnitOfWorkListener}s are notified.

  If the rollback is a result of an exception, consider using {@link #rollback(Throwable)} instead.

• org.b3log.latke.repository.Transaction.rollback()
  Rolls back this transaction.

  Throws:
  {@link java.lang.IllegalStateException} - if the transaction has alreadybeen committed, rolled back

• org.castor.persist.TransactionContext.rollback()
  Rolls back all changes and closes the transaction releasing all locks on all objects. All objects are now transient, if they were queried in this transaction. This method may be called at any point during the transaction. Throws an IllegalStateException if transaction is not in the proper state to perform this operation.
• org.codehaus.activemq.service.Transaction.rollback()
• org.compass.core.CompassSession.rollback()
• org.compiere.util.Trx.rollback()
• org.conserve.connection.ConnectionWrapper.rollback()
  Rolls back all pending transactions on this ConnectionWrapper's connection. @throws SQLException
• org.deuce.transaction.Context.rollback()
  Called on rollback, rollback might be called more than once in a row. But, can't be called after {@link #commit()} without an {@link #init()} call in between. @return TODO
• org.drools.persistence.Transaction.rollback()
• org.drools.persistence.TransactionManager.rollback()
• org.ethereum.facade.Repository.rollback()
  Undo all the changes made so far to a snapshot of the repository
• org.exolab.castor.jdo.Database.rollback()
  Rolls back and closes the transaction. All changes made to persistent objects during the transaction are lost, objects created during the transaction are not made durable and objects removed during the transaction continue to exist. @throws TransactionNotInProgressException Method called whiletransaction is not in progress
• org.exolab.jms.persistence.DatabaseService.rollback()
  Rollback the current transaction. @throws PersistenceException if the transaction can't be rolled back
• org.exoplatform.services.jcr.impl.backup.DataRestore.rollback()
  Rollback changes. @throws RestoreException if any exception is occurred
• org.exoplatform.services.jcr.impl.backup.JCRRestor.rollback()
• org.exoplatform.services.jcr.impl.backup.JCRRestore.rollback()
• org.exoplatform.services.jcr.impl.clean.rdbms.DBCleanerTool.rollback()
  Tries to restore previous data by renaming tables etc (related to specific database) or does nothing.
  This method does not invoke commit or rollback on {@link Connection} butneeded autocommit mode can be set. @throws DBCleanException
• org.exoplatform.services.jcr.storage.WorkspaceStorageConnection.rollback()
  Refuses persistent changes and closes connection. It can be database transaction rollback for instance etc. @throws IllegalStateException if connection is already closed @throws RepositoryException if some exception occured
• org.freeplane.core.undo.IUndoHandler.rollback()
• org.freeplane.features.mode.ModeController.rollback()
• org.fto.jthink.jdbc.JDBCTransaction.rollback()
• org.geomajas.spring.ReconfigurableApplicationContext.rollback()
  Roll back to the previous configuration. @throws GeomajasException indicates an unlikely problem with the rollback (see cause)
• org.geotools.data.DefaultTransaction.rollback()
  Rollsback all modifications against this Transaction.

  This implementation will call rollback() on all State managed by this Transaction. This allows DataStores to provide their own implementation of rollback().

  @throws IOException Encountered problem maintaining transaction State @throws DataSourceException IOException @see org.geotools.data.Transaction#rollback()
• org.geotools.data.Transaction.rollback()
  Undoes all transactions made since the last commit or rollback.

  FeatureSources will need to issue any changes notifications using a FeatureEvent.FEATURES_CHANGED. This will need to be issued to all FeatureSources with the same typeName and Transaction.

  @throws DataSourceException if there are problems with the datasource. @throws UnsupportedOperationException if the rollback method is notsupported by this datasource. @see #setAutoCommit(boolean)
• org.geotools.data.VersioningFeatureStore.rollback()
• org.gridkit.coherence.txlite.TxSession.rollback()
• org.h2.engine.Session.rollback()
  Fully roll back the current transaction.
• org.helidb.txn.Transaction.rollback()
  Roll back the transaction. This discards all changes made and ends it. Future calls to {@link #getCurrentTransactionOrNull()} by this threadwill return {@code null} until a new transaction is started. @throws IllegalStateException If this transaction has already beencommitted or rolled back.
• org.hibernate.Transaction.rollback()
  Force the underlying transaction to roll back. @throws HibernateException
• org.hornetq.api.core.client.ClientSession.rollback()
  Rolls back the current transaction. @throws HornetQException if an exception occurs while rolling back the transaction
• org.hornetq.core.paging.PageTransactionInfo.rollback()
• org.hornetq.core.server.ServerSession.rollback()
• org.hornetq.core.transaction.Transaction.rollback()
• org.hornetq.core.transaction.impl.BindingsTransactionImpl.rollback()
• org.hornetq.core.transaction.impl.TransactionImpl.rollback()
• org.huihoo.workflow.store.persistent.UserTransaction.rollback()
  Rollbacks user transaction. This method is called when commit method fails. @exception TransactionException If something unexpected happens.
• org.infinispan.container.entries.CacheEntry.rollback()
  Rolls back changes
• org.infinispan.transaction.TransactionCoordinator.rollback()
• org.infinispan.transaction.impl.TransactionCoordinator.rollback()
• org.infinispan.transaction.tm.DummyTransactionManager.rollback()
• org.jboss.as.domain.controller.plan.RolloutPlanController.rollback()
• org.jboss.as.logging.logmanager.ConfigurationPersistence.rollback()
  Rolls back the runtime changes.
• org.jboss.cache.commands.ReversibleCommand.rollback()
  Reverses a command that has already been invoked. Important: this method will be invoked at the end of interceptors chain. It should never be called directly from a custom interceptor.
• org.jboss.cache.commands.legacy.ReversibleCommand.rollback()
  Reverses a command that has already been invoked.

  Important: this method will be invoked at the end of interceptors chain. It should never be called directly from a custom interceptor.

• org.jboss.cache.loader.CacheLoader.rollback()
  Rolls the transaction back. A DB-based CacheLoader would look up the local JDBC transaction asociated with tx and roll back that transaction. @param tx transaction to roll back
• org.jboss.cache.transaction.DummyTransactionManager.rollback()
• org.jboss.forge.addon.resource.transaction.ResourceTransaction.rollback()
  Discards this transaction and the associated changes with it
• org.jboss.internal.soa.esb.rosetta.pooling.JmsSession.rollback()
• org.jboss.messaging.core.impl.tx.Transaction.rollback()
• org.jboss.messaging.core.tx.Transaction.rollback()
• org.jboss.narayana.blacktie.jatmibroker.jab.JABTransaction.rollback()
• org.jboss.seam.transaction.SeamApplicationException.rollback()
• org.jboss.seam.transaction.UserTransaction.rollback()
• org.jboss.soa.esb.helpers.persist.JdbcCleanConn.rollback()
• org.jboss.test.jca.adapter.TestConnection.rollback()
• org.jooq.TransactionProvider.rollback()
  @param Configuration the configuration scoped to this transaction and itsnested transactions. @param transaction The user-defined transaction object returned from{@link #begin(TransactionContext)}. May be null. @param cause The exception that has caused the rollback. @throws DataAccessException Any exception issued by the underlyingdatabase.
• org.jooq.impl.DefaultConnectionProvider.rollback()
  Convenience method to access {@link Connection#rollback()}.
• org.jquantlib.methods.finitedifferences.StandardFiniteDifferenceModel.rollback()
• org.jquantlib.methods.finitedifferences.StandardSystemFiniteDifferenceModel.rollback()
• org.jquantlib.pricingengines.hybrid.DiscretizedConvertible.rollback()
• org.jtester.module.database.environment.DBEnvironment.rollback()
  Rollback current transaction.
• org.jugile.proto2.domain.Domain.rollback()
• org.jugile.util.DBConnection.rollback()
• org.jvnet.hk2.config.Transaction.rollback()
  Rollbacks all participants to this transaction.
• org.keycloak.models.KeycloakTransaction.rollback()
• org.lab41.dendrite.metagraph.DendriteGraph.rollback()
• org.lab41.dendrite.metagraph.DendriteGraphTx.rollback()
• org.lab41.dendrite.metagraph.MetaGraphTx.rollback()
• org.lealone.hbase.transaction.Transaction.rollback()
• org.locationtech.udig.project.command.UndoableCommand.rollback()
  Rollback the effects of the command @throws Exception
• org.locationtech.udig.project.command.UndoableMapCommand.rollback()
• org.mapdb.DB.rollback()
  Rollback changes made on collections loaded by this DB @see org.mapdb.Engine#rollback()
• org.modeshape.jcr.txn.Transactions.Transaction.rollback()
• org.mule.api.exception.RollbackSourceCallback.rollback()
• org.mule.api.transaction.Transaction.rollback()
  Rollback the transaction @throws TransactionException
• org.neo4j.neoclipse.graphdb.GraphDbServiceManager.rollback()
  Roll back transaction. @return
• org.objectweb.speedo.workingset.api.TransactionItf.rollback()
  Rolles back the transaction. @throws SpeedoRuntimeException If the rollback process fails
• org.ofbiz.entity.Delegator.rollback()
• org.ofbiz.entity.GenericDelegator.rollback()
• org.ofbiz.entity.jdbc.SQLProcessor.rollback()
  Rollback all modifications
• org.omg.CosTransactions.Current.rollback()
• org.omg.CosTransactions.Resource.rollback()
• org.openbp.server.ProcessFacade.rollback()
  Rolls back the transaction on the token context store.
• org.openntf.domino.transactions.DatabaseTransaction.rollback()
• org.openrdf.http.server.helpers.ServerConnection.rollback()
• org.openrdf.repository.RepositoryConnection.rollback()
  Rolls back all updates that have been performed as part of this connection so far. @throws StoreException If the connection could not be rolled back, or if the connection does not have an active connection. @see #isAutoCommit() @see #begin()
• org.openrdf.repository.sail.SailRepositoryConnection.rollback()
• org.openrdf.sail.NotifyingSailConnection.rollback()
• org.openrdf.sail.SailConnection.rollback()
  Rolls back the SailConnection, discarding any uncommitted changes that have been made in this SailConnection. @throws StoreException If the SailConnection could not be rolled back, or if the connection does not have an active connection.
• org.opensolaris.opengrok.jdbc.ConnectionResource.rollback()
  Abort the transaction. @throws SQLException if a database error occurs
• org.orm.PersistentTransaction.rollback()
• org.osgi.service.deploymentadmin.spi.ResourceProcessor.rollback()
  Called when the processing of the current deployment package is finished. This method is called if the processing of the current deployment package was unsuccessful, and the changes made during the processing of the deployment package should be removed.
• org.ozoneDB.ExternalTransaction.rollback()
  Rollback the transaction associated with the current thread. When this method completes, the thread becomes associated with no transaction. Calling this method when the transaction is not opened doe not throw an exception.

  This method can be called by any threads.

• org.pentaho.reporting.engine.classic.core.layout.Renderer.rollback()
• org.picketlink.idm.api.Transaction.rollback()
• org.sleuthkit.datamodel.SleuthkitCase.CaseDbTransaction.rollback()
• org.springframework.jdbc.datasource.DataSourceTransactionManager.rollback()
• org.springframework.transaction.PlatformTransactionManager.rollback()
  Perform a rollback of the given transaction.

  If the transaction wasn't a new one, just set it rollback-only for proper participation in the surrounding transaction. If a previous transaction has been suspended to be able to create a new one, resume the previous transaction after rolling back the new one.

  Do not call rollback on a transaction if commit threw an exception. The transaction will already have been completed and cleaned up when commit returns, even in case of a commit exception. Consequently, a rollback call after commit failure will lead to an IllegalTransactionStateException. @param status object returned by the getTransaction method @throws TransactionSystemException in case of rollback or system errors(typically caused by fundamental resource failures) @throws IllegalTransactionStateException if the given transactionis already completed (that is, committed or rolled back)

• org.springframework.transaction.jta.JtaTransactionManager.rollback()
• org.springframework.transaction.support.AbstractPlatformTransactionManager.rollback()
  This implementation of rollback handles participating in existing transactions. Delegates to doRollback and doSetRollbackOnly. @see #doRollback @see #doSetRollbackOnly
• org.sql2o.Connection.rollback()
• org.switchyard.component.bpm.transaction.AS7TransactionHelper.rollback()
  Rollback. @throws HandlerException oops
• org.teiid.client.DQP.rollback()
• org.tmatesoft.hg.internal.Transaction.rollback()
  Undo all the changes
• org.tmatesoft.sqljet.core.table.SqlJetDb.rollback()
  Rollback transaction. @throws SqlJetException
• ptolemy.backtrack.Checkpoint.rollback()
  Rollback all the monitored objects to their previous states defined by the given timestamp (or, handle). The records used in the rollback are automatically deleted. This is the same as rollback(timestamp, true). @param timestamp The timestamp taken at a previous time. @see #rollback(long,boolean)
• railo.runtime.db.DataSourceManager.rollback()
  rollback hanging transaction @throws DatabaseException
• realcix20.utils.DAO.rollback()
• ru.yandex.strictweb.ajaxtools.orm.ORMManager.rollback()
• uk.co.oliwali.HawkEye.entry.DataEntry.rollback()
  Rolls back the data entry on the specified block Default is to return false, however extending classes can override this and do their own thing @param block @return true if rollback is performed, false if it isn't
• unibg.overencrypt.core.UploadManager.rollBack()
• voldemort.store.readonly.ReadOnlyStorageEngine.rollback()
  Rollback to the specified push version @param rollbackToDir The full path of the version directory to rollbackto

Examples of org.h2.engine.Session.rollback()

Examples of org.helidb.txn.Transaction.rollback()

Examples of org.hibernate.Transaction.rollback()

Examples of org.hornetq.api.core.client.ClientSession.rollback()

Examples of org.hornetq.core.paging.PageTransactionInfo.rollback()

Examples of org.hornetq.core.server.ServerSession.rollback()

Examples of org.hornetq.core.transaction.Transaction.rollback()

Examples of org.hornetq.core.transaction.impl.BindingsTransactionImpl.rollback()

Examples of org.hornetq.core.transaction.impl.TransactionImpl.rollback()

Examples of org.huihoo.workflow.store.persistent.UserTransaction.rollback()