Examples of Transaction

  • org.datanucleus.transaction.Transaction
    Transaction The Global Transaction ID is formed as: TX---
  • org.dmlite.model.action.Transaction
    Encapsulates a transaction in a session. A transaction keeps a history of actions on entities. A transaction may be executed or undone. To be successful, all transaction actions must be successful. Domain model observers are informed about the execute or undo events. @author Dzenan Ridjanovic @version 2006-11-20
  • org.drools.persistence.Transaction
  • org.eclipse.bpmn2.Transaction
    A representation of the model object 'Transaction'.

    The following features are supported:

    @see org.eclipse.bpmn2.Bpmn2Package#getTransaction() @model extendedMetaData="name='tTransaction' kind='elementOnly'" @generated
  • org.eclipse.emf.transaction.Transaction
  • org.eclipse.jetty.plus.jndi.Transaction
    Transaction Class to represent a JTA UserTransaction impl.
  • org.ethereum.core.Transaction
    A transaction (formally, T) is a single cryptographically signed instruction sent by an actor external to Ethereum. An external actor can be a person (via a mobile device or desktop computer) or could be from a piece of automated software running on a server. There are two types of transactions: those which result in message calls and those which result in the creation of new contracts.
  • org.evolizer.versioncontrol.cvs.model.entities.Transaction
    A transaction is a set of files that were committed together to a CVS server (aka. Change Set). CVS does not store transactions, but they can be more or less reconstructed using some heuristics. @author wuersch, jetter
  • org.exist.fluent.Transaction
    A transaction on the database. This can be either a top-level transaction, or a "nested" transaction. Nested transactions do nothing on commit and abort. All transactions will only execute a commit or abort once, all further invocations do nothing. This makes it convenient to put abort in a finally clause -- it will only have an effect if no commit was reached beforehand. @author Piotr Kaminski
  • org.fusesource.hawtdb.api.Transaction
    irino.com">Hiram Chirino
  • org.g4studio.core.orm.xibatis.sqlmap.engine.transaction.Transaction
  • org.geotools.data.Transaction
    ide authoriztion road.removeFeatures( filter ); // operate against transaction river.removeFeature( filter ); // operate against transaction t.commit(); // commit operations } catch (IOException io){ t.rollback(); // cancel operations } finally { t.close(); // free resources }

    Example code walkthrough (from the perspective of Transaction):

    1. A new transaction is created (an instanceof DefaultTransaction with a handle)
    2. A hint is provided using Transaction.putProperty( key, value )
    3. Transaction is provided to two FeatureStores, this may result in Transaction.State instances being registered
      • TransactionStateDiff (stored by DataStore): Used for in memory locking is used by many DataStore's (like ShapefileDataStore). Lazy creation by AbstractDataStore.state(transaction).
      • JDBCTransactionState (stored by ConnectionPool): Used to manage connection rollback/commit. Lazy creation as part of JDBCDataStore.getConnection(transaction).
      • InProcessLockingManager.FeatureLock (stored by LockingManger): Used for per transaction FeatureLocks, used to free locked features on Transaction commit/rollback.
      These instances of Transaction state may make use of any hint provided to Transaction.putProperty( key, value ) when they are connected with Transaction.State.setTransaction( transaction ).
    4. t.addAuthorization(lockID) is called, each Transaction.State has its addAuthroization(String) callback invoked with the value of lockID
    5. FeatureStore.removeFeatures methods are called on the two DataStores.
      • PostgisFeatureStore.removeFeatures(fitler) handles operation without delegation.
      • Most removeFeature(filter) implementations use the implementation provided by AbstractFeatureStore which delegates to FeatureWriter.
      Any of these operations may make use of the Transaction.putProperty( key, value ).
    6. The transaction is commited, all of the Transaction.State methods have there Transaction.State.commit() methods called gicing them a chance to applyDiff maps, or commit various connections.
    7. The transaction is closed, all of the Transaction.State methods have there Transaction.State.setTransaction( null ) called, giving them a chance to clean up diffMaps, or return connections to the pool.
    @author Jody Garnett @author Chris Holmes, TOPP @source $URL$ @version $Id$
  • org.helidb.txn.Transaction
    ikipedia.org/wiki/ACID">this Wikipedia article. At the end of the logical operation, it is either {@link #commit()}:ed, i.e. persisted to the database storage, or {@link #rollback()}:ed, i.e. discarded.

    A transaction always involves just one execution thread. Several different threads may have their own transactions, and the transactions' ACID:ity properties guarantee that they will never see data in an intermediate state. This is accomplished by the thread locking implemented in the involved databases.

    HeliDB has both read/write and read only transactions. It is up to the {@link org.helidb.Database} implementation used if they are treateddifferently. For instance, a {@code Database} could allow several concurrentread only transactions, but only one simultaneous transaction if that transaction is read/write.

    A new transaction is started by any of the static {@link #startTransaction(boolean)} or {@link #getOrStartTransaction(boolean)}methods. If the thread already is involved in a transaction and wants to get that transaction's {@code Transaction} object, it can call any of the staticgetter methods.

    Implementation note:
    A database joins a {@code Transaction} via its{@link TransactionCollaborator}. It uses one collaborator object per transaction it is involved in. The collaborator keeps track of the state for the database associated with just that transaction. @author Karl Gustafsson @since 1.0 @see TransactionCollaborator @see TransactionalDatabase

  • org.hibernate.Transaction
    Allows the application to define units of work, while maintaining abstraction from the underlying transaction implementation (eg. JTA, JDBC).

    A transaction is associated with a Session and is usually instantiated by a call to Session.beginTransaction(). A single session might span multiple transactions since the notion of a session (a conversation between the application and the datastore) is of coarser granularity than the notion of a transaction. However, it is intended that there be at most one uncommitted Transaction associated with a particular Session at any time.

    Implementors are not intended to be threadsafe. @see Session#beginTransaction() @see org.hibernate.transaction.TransactionFactory @author Anton van Straaten
  • org.hornetq.core.transaction.Transaction
    A HornetQ internal transaction @author Tim Fox @author org.infinispan.client.hotrod.protostream.domain.Transaction
    @author anistor@redhat.com
  • org.infinispan.protostream.domain.Transaction
    @author anistor@redhat.com
  • org.infinispan.protostream.sampledomain.Transaction
    @author anistor@redhat.com
  • org.infinispan.query.dsl.embedded.sample_domain_model.Transaction
    @author anistor@redhat.com @since 6.0
  • org.infinispan.query.dsl.embedded.testdomain.Transaction
    @author anistor@redhat.com @since 6.0
  • org.jboss.identity.idm.api.Transaction
    Transaction @author Boleslaw Dawidowicz @version : 0.1 $
  • org.jboss.messaging.core.impl.tx.Transaction
    A JMS Server local transaction @author Tim Fox @author Ovidiu Feodorov @version $Revision 1.1$$Id: Transaction.java 7966 2010-03-03 14:50:50Z gaohoward $
  • org.jboss.messaging.core.tx.Transaction
    A JMS Server local transaction @author Tim Fox @author Ovidiu Feodorov @version $Revision 1.1$$Id: Transaction.java 2313 2007-02-14 20:25:03Z timfox $
  • org.jboss.narayana.blacktie.jatmibroker.jab.factory.Transaction
    The JABTransaction provides the programmer access to the underlying transaction object it can be committed or rolled back at most once. @see JABConnection
  • org.jboss.test.banknew.interfaces.Transaction
    Remote interface for bank/Transaction.
  • org.jbpm.pvm.internal.env.Transaction
    provides access to the transaction in the environment. @author Tom Baeyens
  • org.jbpm.pvm.internal.tx.Transaction
    provides access to the transaction in the environment. @author Tom Baeyens
  • org.jbpm.tx.Transaction
    @author Tom Baeyens
  • org.jpox.Transaction
    Representation of a transaction within JPOX. This interface is not user application visible. Handling of transactions in JPOX is split in 4 layers:
  • In the the API layer, there are interfaces provided to the user application, as such:
  • In the ObjectManager layer, the {@link org.jpox.Transaction} interface defines the contractfor handling transactions for the ObjectManager. In the X/Open/JTA layer the handling of XA resources is done. It means, XAResources are obtained and enlisted to a TransactionManager. The TransactionManager will commit or rollback the resources at the end of the transactions. There are two kinds of TransactionManager: JPOX and JTA. A JTA TransactionManager is external to JPOX, while the JPOX TransactionManager is implemented by JPOX as {@link org.jpox.transaction}. The JPOX TransactionManager is used when the DataSource used to obtain connections to the underlying database is not enlisted in an external JTA TransactionManager. The JTA TransactionManager is usually found when running in J2EE application servers, however nowadays there are many JTA containers that can be used in J2SE. The scenarios where a JTA TransactionManager is used is: When an JTA TransactionManager exists, and the connections to the underlying databases are acquired via transactional DataSources. That means, when you ask a connection to the DataSource, it will automatically enlist it in a JTA TransactionManager. The Resource layer is handled by the datastore. For example, with RDBMS databases, the javax.sql.Connection is the API used to demarcate the database transactions. In The RBDMS database, the resource layer, it is handling the database transaction. @version $Revision: 1.27 $
  • org.jpox.transaction.Transaction
    Transaction The Global Transaction ID is formed as: TX---
  • org.jscep.transaction.Transaction
    This class represents an abstract SCEP transaction.
  • org.jvnet.hk2.config.Transaction
    Simple transaction mechanism for config-api objects @author Jerome Dochez
  • org.kapott.hbci.GV_Result.GVRWPDepotUms.Entry.FinancialInstrument.Transaction
  • org.lealone.hbase.transaction.Transaction
  • org.modeshape.jcr.txn.Transactions.Transaction
  • org.mule.api.transaction.Transaction
  • org.neo4j.graphdb.Transaction
    operation that works with the node space tx.success(); } finally { tx.finish(); }

    Let's walk through this example line by line. First we retrieve a Transaction object by invoking the {@link GraphDatabaseService#beginTx()} factory method.This creates a new Transaction instance which has internal state to keep track of whether the current transaction is successful. Then we wrap all operations that work with the node space in a try-finally block. At the end of the block, we invoke the {@link #finish() tx.success()} method to indicatethat the transaction is successful. As we exit the block, the finally clause will kick in and {@link #finish() tx.finish} will commit the transaction ifthe internal state indicates success or else mark it for rollback.

    If an exception is raised in the try-block, {@link #success()} will never beinvoked and the internal state of the transaction object will cause {@link #finish()} to roll back the transaction. This is very important:unless {@link #success()} is invoked, the transaction will fail upon{@link #finish()}. A transaction can be explicitly marked for rollback by invoking the {@link #failure()} method.

    Read operations inside of a transaction will also read uncommitted data from the same transaction.

  • org.nutz.trans.Transaction
  • org.odmg.Transaction
    This interfaces provides the operations necessary to perform database transactions. All access, creation, and modification of persistent objects and their fields must be done within a transaction. Before performing any database operations, a thread must explicitly create a transaction object or associate itself with an existing transaction object (by calling join), and that transaction must be open (through a call to begin). All subsequent operations by the thread, including reads, writes, and lock acquisitions, are done under the thread�s current transaction.

    A thread may only operate on its current transaction. For example, a TransactionNotInProgressException is thrown if a thread attempts to begin, commit, checkpoint, or abort a transaction prior to joining itself to that transaction.

    A transaction is either open or closed. A transaction is open if a call has been made to begin, but no call has been made to commit or abort. Once commit or abort is called, the transaction is closed. The method isOpen can be called to determine the state of the transaction.

    Read locks are implicitly obtained on objects as they are accessed. Write locks are implicitly obtained as objects are modified. Transaction objects are transient, they cannot be stored in the database. @author David Jordan (as Java Editor of the Object Data Management Group) @version ODMG 3.0 @see TransactionNotInProgressException

  • org.openbankdata.core.Transaction
    Transaction model class.
  • org.persvr.data.Transaction
    This class represents a data transaction, tracking the changes to data so they can be atomically committed to a data source. Transactions are associated with threads. @author Kris
  • org.picketlink.idm.api.Transaction
  • org.prevayler.Transaction
    An atomic transaction to be executed on a Prevalent System.

    To be recoverable, any changes to the observable state of a Prevalent System must be encapsulated in Transactions and performed via the given prevalentSystem in each Transaction.

    Upon recovery execution, anything outside prevalentSystem will be a freshly deserialized copy, so cannot reference anything in the Prevalent System.
    @param < P> The type or any supertype of the Prevalent System you intend to perform the transaction upon.
  • org.rascalmpl.tasks.Transaction
  • org.teiid.adminapi.Transaction
  • org.tmatesoft.hg.internal.Transaction
    Implementation strategies possible: @author Artem Tikhomirov @author TMate Software Ltd.
  • org.voltdb.benchmark.overhead.OverheadClient.Transaction
  • org.xrace.desjardins.reponse.Transaction
    pure xml @version $Revision$ $Date$
  • org.xrace.desjardins.request.Transaction
    Class Transaction. @version $Revision$ $Date$
  • org.xrace.desjardins.trx.Transaction
    Class Transaction. @version $Revision$ $Date$
  • org.xrace.model.paiement.Transaction
  • org.xtreemfs.babudb.api.transaction.Transaction
    A lightweight BabuDB transaction.

    A transaction is a sorted collection of modifications that is executed atomically. Transactions resemble {@link DatabaseInsertGroup}s, but they may contain modifications across multiple databases, creations and deletions of databases as well as snapshot operations.

    BabuDB transactions are called lightweight, as their semantics differ from the ones typically provided by database systems. The most important differences are:

  • redis.clients.jedis.Transaction
    Transaction is nearly identical to Pipeline, only differences are the multi/discard behaviors
  • sg.edu.nus.iss.se07.bc.Transaction
    @author Isak Rabin @version 0.1 @since v0.1 (21/03/2009)
  • statement.Transaction
  • uk.org.woodcraft.bookings.datamodel.Transaction
  • xbird.storage.tx.Transaction
    @author Makoto YUI (yuin405+xbird@gmail.com)

  • Examples of Utils.Transaction

            double dblAmount=Validate();
                mwcHost.getTab(lstFrom.getSelectedValue().toString()).addTransaction(new Transaction(Transaction.ID_NOT_SET, -dblAmount, TransferController.TransferMinus,  DateTool.getDate(txtDate.getText())));
                mwcHost.getTab(lstTo.getSelectedValue().toString()).addTransaction(new Transaction(Transaction.ID_NOT_SET, dblAmount, TransferController.TransferPlus,  DateTool.getDate(txtDate.getText())));
            catch(Exception ef)
    View Full Code Here

    Examples of br.gov.frameworkdemoiselle.transaction.Transaction

        return result;

      private void initiate(final InvocationContext ic) {
        Transaction transaction = getTransactionContext().getCurrentTransaction();
        TransactionInfo transactionInfo = getTransactionInfo();

        if (!transaction.isActive()) {

    View Full Code Here

    Examples of ca.uhn.fhir.rest.annotation.Transaction

        History history = theMethod.getAnnotation(History.class);
        Validate validate = theMethod.getAnnotation(Validate.class);
        GetTags getTags = theMethod.getAnnotation(GetTags.class);
        AddTags addTags = theMethod.getAnnotation(AddTags.class);
        DeleteTags deleteTags = theMethod.getAnnotation(DeleteTags.class);
        Transaction transaction = theMethod.getAnnotation(Transaction.class);
        // ** if you add another annotation above, also add it to the next line:
        if (!verifyMethodHasZeroOrOneOperationAnnotation(theMethod, read, search, conformance, create, update, delete, history, validate, getTags, addTags, deleteTags, transaction)) {
          return null;

    View Full Code Here

    Examples of cirrus.hibernate.Transaction

        protected String doExecute(  )
            throws Exception
            Session     s = getHibernateSession(  );
            Transaction tx = null;

                tx = s.beginTransaction(  );

                /* Customer */
                Customer cst = ( Customer ) s.load( Customer.class, getUserId(  ) );

                /* Order + Items*/
                Order    order = new Order( cst );
                Map      cart = getCart(  );
                Iterator it = cart.keySet(  ).iterator(  );

                while ( it.hasNext(  ) )
                    String  itemId = ( String ) it.next(  );
                    Item    item = ( Item ) s.load( Item.class, itemId );
                    Integer quantity = ( Integer ) cart.get( itemId );
                    order.add( item, quantity.intValue(  ) );

                /* Save */
                s.save( order );
                tx.commit(  );

                /* Empty the cart */
                getCart(  ).clear(  );

                /* send the email */
                String subject = "[xpetstore] Order Confimation";
                String body = "Your order has been submitted.\nThe order number is: " + order.getOrderId(  );

                    MailUtil.send( cst.getEmail(  ), subject, body );
                catch ( Exception e )
                    _log.error( "Unexpected error while sending email", e );

                return SUCCESS;
            catch ( Exception e )
                _log.error( "Unexpected error", e );

                if ( tx != null )
                    tx.rollback(  );

                throw e;
    View Full Code Here

    Examples of co.cask.tephra.Transaction

    public class DequeueScanObserver extends BaseRegionObserver {
      public RegionScanner preScannerOpen(ObserverContext<RegionCoprocessorEnvironment> e, Scan scan, RegionScanner s)
        throws IOException {
        ConsumerConfig consumerConfig = DequeueScanAttributes.getConsumerConfig(scan);
        Transaction tx = DequeueScanAttributes.getTx(scan);
        byte[] queueRowPrefix = DequeueScanAttributes.getQueueRowPrefix(scan);

        if (consumerConfig == null || tx == null || queueRowPrefix == null) {
          return super.preScannerOpen(e, scan, s);
    View Full Code Here

    Examples of com.Acrobot.ChestShop.DB.Transaction


            double pricePerStack = event.getPrice() / event.getStock().length;

            for (ItemStack item : event.getStock()) {
                Transaction transaction = new Transaction();



                transaction.setPrice((float) pricePerStack);


                transaction.setSec(System.currentTimeMillis() / 1000);
                transaction.setBuy(event.getTransactionType() == BUY);

    View Full Code Here

    Examples of com.arjuna.ats.jta.transaction.Transaction

        private TransactionManager transactionManager;

        protected int getTimeout() {
            try {
                Transaction tx = (Transaction) transactionManager.getTransaction();
                return tx.getTimeout();
            } catch (Exception e)
                return -1;
    View Full Code Here

    Examples of com.avaje.ebean.Transaction

        List<UTMaster> masters = new ArrayList<UTMaster>();
        for (int i = 0; i < numOfMasters; i++) {

        Transaction transaction = Ebean.beginTransaction();
        try {
          // transaction.setLogLevel(LogLevel.SUMMARY);
          // transaction.setBatchGetGeneratedKeys(false);



        } finally {
    View Full Code Here

    Examples of com.bitsofproof.supernode.api.Transaction

        if ( fee < 0 || fee > MAXIMUM_FEE )
          throw new ValidationException ("You unlikely want to do that");
        Transaction transaction = new Transaction ();
        transaction.setInputs (new ArrayList<TransactionInput> ());
        transaction.setOutputs (new ArrayList<TransactionOutput> ());

        long sumOut = 0;
        for ( TransactionSink s : sinks )
          TransactionOutput o = new TransactionOutput ();
          o.setValue (s.getValue ());
          sumOut += s.getValue ();
          o.setScript (s.getAddress ().getAddressScript ());

          transaction.getOutputs ().add (o);

        long sumInput = 0;
        for ( TransactionOutput o : sources )
          TransactionInput i = new TransactionInput ();
          i.setSourceHash (o.getTxHash ());
          i.setIx (o.getIx ());
          sumInput += o.getValue ();

          transaction.getInputs ().add (i);
        if ( sumInput != (sumOut + fee) )
          throw new ValidationException ("Sum of sinks (+fee) does not match sum of sources");

        int j = 0;
        for ( TransactionOutput s : sources )
          TransactionInput i = transaction.getInputs ().get (j);
          ScriptFormat.Writer sw = new ScriptFormat.Writer ();
          if ( ScriptFormat.isPayToAddress (s.getScript ()) )
            Address address = s.getOutputAddress ();
            Key key = getKeyForAddress (address);
            if ( key == null )
              throw new ValidationException ("Have no key to spend this output");
            byte[] sig = key.sign (hashTransaction (transaction, j, ScriptFormat.SIGHASH_ALL, s.getScript ()));
            byte[] sigPlusType = new byte[sig.length + 1];
            System.arraycopy (sig, 0, sigPlusType, 0, sig.length);
            sigPlusType[sigPlusType.length - 1] = (byte) (ScriptFormat.SIGHASH_ALL & 0xff);
            sw.writeData (sigPlusType);
            sw.writeData (key.getPublic ());
            spendNonAddressOutput (j, s, sw, transaction);
          i.setScript (sw.toByteArray ());

        transaction.computeHash ();
        return transaction;
    View Full Code Here

    Examples of com.buschmais.cdo.api.Transaction

        public Object invoke(InvocationContext context) throws Throwable {
            Method method = context.getMethod();
            Transaction.TransactionAttribute transactionAttribute;
            Transaction transaction = method.getAnnotation(Transaction.class);
            if (transaction != null) {
                transactionAttribute = transaction.value();
            } else {
                transactionAttribute = this.defaultTransactionAttribute;
            switch (transactionAttribute) {
                case MANDATORY:
    View Full Code Here
    Copyright © 2018 www.massapi.com. All rights reserved.
    All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.