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 net.sourceforge.wampum.finance.entities.Transaction

        }
       
        private static final String TRANS_BY_FIT_ID_SQL = "SELECT TRANSACTION_ID FROM TRANSACTIONS WHERE FITID = ?";
       
        public Transaction loadTransactionByFitID(String fitID) {
          Transaction retVal = null;
            PreparedStatement preparedStatement = null;
            ResultSet resultSet = null;
            try {
                preparedStatement = conn.prepareStatement(TRANS_BY_FIT_ID_SQL);
                preparedStatement.setString(1, fitID);
    View Full Code Here

    Examples of oracle.olapi.transaction.Transaction

        // ***** Beginning of the Using Child Transaction Objects example *****

        // The parent Transaction is the current Transaction at this point.
        // Save the parent read Transaction as parentT1.
        Transaction parentT1 = getCurrentTransaction();

        // Get the dynamic Source produced by the TopBottomTemplate.
        // The next line from this example is commented out because the
        // result object was created by the previous example.
        //Source result = topNBottom.getSource();

        // Create a Cursor and display the results.
        println("\nThe current state of the TopBottomTemplate" +
                "\nproduces following values:\n");
        getContext().displayTopBottomResult(result);

        // Begin a child Transaction of parentT1.
        tp.beginSubtransaction()// This is a read Transaction.

        // Save the child read Transaction as childT2.
        Transaction childT2 = tp.getCurrentTransaction();

        // Change the state of the TopBottomTemplate. This starts a
        // write Transaction, a child of the read Transaction childT2.
        topNBottom.setN(12);
        topNBottom.setTopBottomType(TopBottomTemplate.TOP_BOTTOM_TYPE_BOTTOM);

        // Save the child write Transaction as writeT3.
        Transaction writeT3 = tp.getCurrentTransaction();

        // Prepare and commit the write Transaction writeT3.
        prepareAndCommit();

        // The commit moves the changes made in writeT3 into its parent,
        // the read Transaction childT2. The writeT3 Transaction
        // disappears. The current Transaction is now childT2
        // again but the state of the TopBottomTemplate has changed.

        // Create a Cursor and display the results of the changes to the
        // TopBottomTemplate that are visible in childT2.
        try
        {
          println("\nIn the child Transaction, the state of the " +
                  "\nTopBottomTemplate produces the following values:\n");
          getContext().displayTopBottomResult(result);
        }
        catch(Exception e)
        {
          println("Cannot display the results of the query. " + e);
        }

        // Begin a grandchild Transaction of the initial parent.
        tp.beginSubtransaction()// This is a read Transaction.

        // Save the grandchild read Transaction as grandchildT4.
        Transaction grandchildT4 = tp.getCurrentTransaction();

        // Change the state of the TopBottomTemplate. This starts another
        // write Transaction, a child of grandchildT4.
        topNBottom.setTopBottomType(TopBottomTemplate.TOP_BOTTOM_TYPE_TOP);

        // Save the write Transaction as writeT5.
        Transaction writeT5 = tp.getCurrentTransaction();

        // Prepare and commit writeT5.
        prepareAndCommit();

        // Transaction grandchildT4 is now the current Transaction and the
    View Full Code Here

    Examples of org.activemq.service.Transaction

         * Rollback an XA Transaction.
         *
         * @see org.activemq.broker.Broker#rollbackTransaction(org.activemq.broker.BrokerClient, org.activemq.message.ActiveMQXid)
         */
        public void rollbackTransaction(BrokerClient client, ActiveMQXid xid) throws XAException {
            Transaction transaction = transactionManager.getXATransaction(xid);
            transaction.rollback();
        }
    View Full Code Here

    Examples of org.activiti.bpmn.model.Transaction

    public class SubProcessParser implements BpmnXMLConstants {
     
      public void parse(XMLStreamReader xtr, List<SubProcess> activeSubProcessList, Process activeProcess) {
        SubProcess subProcess = null;
        if (ELEMENT_TRANSACTION.equalsIgnoreCase(xtr.getLocalName())) {
          subProcess = new Transaction();
        } else if (ATTRIBUTE_VALUE_TRUE.equalsIgnoreCase(xtr.getAttributeValue(null, ATTRIBUTE_TRIGGERED_BY))) {
          subProcess = new EventSubProcess();
        } else {
          subProcess = new SubProcess();
        }
    View Full Code Here

    Examples of org.apache.activemq.store.kahadb.disk.page.Transaction

    public class HashIndexBenchMark extends IndexBenchmark {

        @Override
        protected Index<String, Long> createIndex() throws Exception {

            Transaction tx = pf.tx();
            long id = tx.allocate().getPageId();
            tx.commit();

            HashIndex<String, Long> index = new HashIndex<String, Long>(pf, id);
            index.setKeyMarshaller(StringMarshaller.INSTANCE);
            index.setValueMarshaller(LongMarshaller.INSTANCE);
           
    View Full Code Here

    Examples of org.apache.activemq.transaction.Transaction

        // ////////////////////////////////////////////////////////////////////////////
        public TransactionId[] getPreparedTransactions(ConnectionContext context) throws Exception {
            List<TransactionId> txs = new ArrayList<TransactionId>();
            synchronized (xaTransactions) {
                for (Iterator<XATransaction> iter = xaTransactions.values().iterator(); iter.hasNext();) {
                    Transaction tx = iter.next();
                    if (tx.isPrepared()) {
                        if (LOG.isDebugEnabled()) {
                            LOG.debug("prepared transaction: " + tx.getTransactionId());
                        }
                        txs.add(tx.getTransactionId());
                    }
                }
            }
            XATransactionId rc[] = new XATransactionId[txs.size()];
            txs.toArray(rc);
    View Full Code Here

    Examples of org.apache.aries.transaction.annotations.Transaction

            while(c != Object.class) {
                for(Method m : c.getDeclaredMethods()) {
                    int modifiers = m.getModifiers();
                    if((modifiers & Constants.BANNED_MODIFIERS) != 0)
                        throw new IllegalArgumentException(Constants.MESSAGES.getMessage("private.or.static.method", m));
              Transaction t = m.getAnnotation(Transaction.class);
              if(t != null && helper.getComponentMethodTxAttribute(arg3, m.getName()) == null) {
                helper.setComponentTransactionData(cdr, arg3, t.value().toString(), m.getName());
               
                outer: if(!!!interceptorAssigned) {
                  for(Interceptor i : cdr.getInterceptors(arg3)) {
                    if(i == interceptor) {
                      interceptorAssigned = true;
    View Full Code Here

    Examples of org.apache.aurora.gen.storage.Transaction

        ScheduledTask snapshotTask = makeTask("snapshotTask", ScheduleStatus.ASSIGNED);
        ScheduledTask transactionTask = makeTask("transactionTask", ScheduleStatus.RUNNING);
        Iterable<Entry> recoveredEntries = toEntries(
            LogEntry.snapshot(new Snapshot().setTasks(ImmutableSet.of(snapshotTask))),
            LogEntry.transaction(new Transaction(
                ImmutableList.of(Op.saveTasks(new SaveTasks(ImmutableSet.of(transactionTask)))),
                storageConstants.CURRENT_SCHEMA_VERSION)));

        expect(log.open()).andReturn(logStream);
        expect(logStream.readAll()).andReturn(recoveredEntries.iterator()).anyTimes();
    View Full Code Here

    Examples of org.apache.cayenne.access.Transaction

            // TODO (andrus, 7/6/2006) Note that this will still work in a pool with a single
            // connection, as PK generator is invoked early in the transaction, before the
            // connection is grabbed for commit... So maybe promote this to other adapters in
            // 3.0?

            Transaction transaction = Transaction.getThreadTransaction();
            Transaction.bindThreadTransaction(null);

            try {

                Connection connection = node.getDataSource().getConnection();
    View Full Code Here

    Examples of org.apache.derby.iapi.store.raw.Transaction

        Properties              properties,
      int                     temporaryFlag)
        throws StandardException
      {
            String      property_value = null;
            Transaction rawtran        = xact_manager.getRawStoreXact();

            if (properties == null)
            {
                throw(StandardException.newException(
                        SQLState.BTREE_PROPERTY_NOT_FOUND, PROPERTY_BASECONGLOMID));
            }

            // Get baseConglomerateId //
            property_value = properties.getProperty(PROPERTY_BASECONGLOMID);
            if (property_value == null)
            {
                throw(StandardException.newException(
                        SQLState.BTREE_PROPERTY_NOT_FOUND, PROPERTY_BASECONGLOMID));
            }

            if (SanityManager.DEBUG)
            {
          if (property_value == null)
                  SanityManager.THROWASSERT(
                      PROPERTY_BASECONGLOMID +
              "property not passed to B2I.create()");
            }

            baseConglomerateId = Long.parseLong(property_value);

            // Get rowLocationColumn //
            property_value = properties.getProperty(PROPERTY_ROWLOCCOLUMN);

            if (SanityManager.DEBUG)
            {
          if (property_value == null)
                  SanityManager.THROWASSERT(
                      PROPERTY_ROWLOCCOLUMN +
              "property not passed to B2I.create()");
            }

            if (property_value == null)
            {
                throw(StandardException.newException(
                        SQLState.BTREE_PROPERTY_NOT_FOUND, PROPERTY_BASECONGLOMID));
            }

            rowLocationColumn = Integer.parseInt(property_value);

            // Currently the row location column must be the last column (makes)
            // comparing the columns in the index easier.
            if (SanityManager.DEBUG)
            {
                SanityManager.ASSERT(rowLocationColumn == template.length - 1,
                    "rowLocationColumn is not the last column in the index");
                SanityManager.ASSERT(
                    template[rowLocationColumn] instanceof
                        RowLocation);

                // There must be at least one key column
          if (rowLocationColumn < 1)
                  SanityManager.THROWASSERT(
              "rowLocationColumn (" + rowLocationColumn +
              ") expected to be >= 1");
            }


        /* convert the sorting order information into a boolean array map.
         * If the sorting order for the columns is not provided, we
         * assign the default as Ascending Order.
         * array length is equal to template length, because column order
         * length changes whether it is unique or is non unique. store assumes
         * template length arrays. So, we make template length array and make
         * the last column as ascending instead of having lot of execeptions
             * code.
         */
       
        ascDescInfo = new boolean[template.length];
        for (int i=0 ; i < ascDescInfo.length; i++)
        {
          if (columnOrder != null && i < columnOrder.length)
            ascDescInfo[i] = columnOrder[i].getIsAscending();
          else
            ascDescInfo[i] = true// default values - ascending order
        }

            // get collation ids from input collation ids, store it in the
            // conglom state.
            collation_ids =
                ConglomerateUtil.createCollationIds(template.length, collationIds);

        // Do the generic part of creating the b-tree.
        super.create(
                rawtran, segmentId, input_conglomid, template,
                properties, getTypeFormatId(), temporaryFlag);

            // open the base conglomerate - to get the lock
            ConglomerateController base_cc =
                xact_manager.openConglomerate(
                    baseConglomerateId,
                    false,
                    TransactionController.OPENMODE_FOR_LOCK_ONLY,
                    TransactionController.MODE_TABLE,
                    TransactionController.ISOLATION_SERIALIZABLE);
           
            OpenBTree open_btree = new OpenBTree();

            BTreeLockingPolicy b2i_locking_policy =
                new B2ITableLocking3(
                    rawtran,
                    TransactionController.MODE_TABLE,
                    rawtran.newLockingPolicy(
                        LockingPolicy.MODE_CONTAINER,
                        TransactionController.ISOLATION_SERIALIZABLE, true),
                    base_cc, open_btree);


    View Full Code Here
    TOP
    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.