Java Environment.getThreadTransaction方法代码示例

import com.sleepycat.je.Environment; //导入方法依赖的package包/类
public boolean delete(Transaction txn, PK key)
       throws DatabaseException {

       DatabaseEntry pkeyEntry = new DatabaseEntry();
       DatabaseEntry dataEntry = BasicIndex.NO_RETURN_ENTRY;
       pkeyBinding.objectToEntry(key, pkeyEntry);

       boolean autoCommit = false;
Environment env = db.getEnvironment();
       if (transactional &&
    txn == null &&
    env.getThreadTransaction() == null) {
           txn = env.beginTransaction(null, null);
           autoCommit = true;
       }

       boolean failed = true;
       OperationStatus status;
       SecondaryCursor cursor = db.openSecondaryCursor(txn, null);
       try {
           status = cursor.getSearchBoth
               (keyEntry, pkeyEntry, dataEntry, LockMode.RMW);
           if (status == OperationStatus.SUCCESS) {
               status = cursor.delete();
           }
           failed = false;
       } finally {
           cursor.close();
           if (autoCommit) {
               if (failed) {
                   txn.abort();
               } else {
                   txn.commit();
               }
           }
       }

       return (status == OperationStatus.SUCCESS);
   }
 

import com.sleepycat.je.Environment; //导入方法依赖的package包/类
/**
 * Get a locker for a read or cursor operation.
 */
private static Locker getReadableLocker(Environment env,
                                        Locker locker,
                                        boolean readCommittedIsolation)
    throws DatabaseException {

    EnvironmentImpl envImpl = DbInternal.getEnvironmentImpl(env);

    if (locker == null) {
        Transaction xaTxn = env.getThreadTransaction();
        if (xaTxn != null) {
            return DbInternal.getLocker(xaTxn);
        }
    }

    if (locker == null) {
        /* Non-transactional user operations use ThreadLocker. */
        locker = ThreadLocker.createThreadLocker(envImpl);
    } else {

        /*
         * Use the given locker.  For read-committed, wrap the given
         * transactional locker in a special locker for that isolation
         * level.
         */
        if (readCommittedIsolation) {
            locker = ReadCommittedLocker.
                createReadCommittedLocker(envImpl, locker);
        }
    }
    return locker;
}
 

import com.sleepycat.je.Environment; //导入方法依赖的package包/类
/**
    * Inserts an entity and returns null, or updates it if the primary key
    * already exists and returns the existing entity.
    *
    * <p>If a {@link PrimaryKey#sequence} is used and the primary key field of
    * the given entity is null or zero, this method will assign the next value
    * from the sequence to the primary key field of the given entity.</p>
    *
    * @param txn the transaction used to protect this operation, null to use
    * auto-commit, or null if the store is non-transactional.
    *
    * @param entity the entity to be inserted or updated.
    *
    * @return the existing entity that was updated, or null if the entity was
    * inserted.
    */
   public E put(Transaction txn, E entity)
       throws DatabaseException {

       DatabaseEntry keyEntry = new DatabaseEntry();
       DatabaseEntry dataEntry = new DatabaseEntry();
       assignKey(entity, keyEntry);

       boolean autoCommit = false;
Environment env = db.getEnvironment();
       if (transactional &&
    txn == null &&
    env.getThreadTransaction() == null) {
           txn = env.beginTransaction(null, null);
           autoCommit = true;
       }

       boolean failed = true;
       Cursor cursor = db.openCursor(txn, null);
       try {
           while (true) {
               OperationStatus status =
                   cursor.getSearchKey(keyEntry, dataEntry, LockMode.RMW);
               if (status == OperationStatus.SUCCESS) {
                   E existing =
                       (E) entityBinding.entryToObject(keyEntry, dataEntry);
                   entityBinding.objectToData(entity, dataEntry);
                   cursor.put(keyEntry, dataEntry);
                   failed = false;
                   return existing;
               } else {
                   entityBinding.objectToData(entity, dataEntry);
                   status = cursor.putNoOverwrite(keyEntry, dataEntry);
                   if (status != OperationStatus.KEYEXIST) {
                       failed = false;
                       return null;
                   }
               }
           }
       } finally {
           cursor.close();
           if (autoCommit) {
               if (failed) {
                   txn.abort();
               } else {
                   txn.commit();
               }
           }
       }
   }
 

import com.sleepycat.je.Environment; //导入方法依赖的package包/类
public static Transaction getThreadTransaction(Environment env)
throws DatabaseException {

       return env.getThreadTransaction();
   }
 

import com.sleepycat.je.Environment; //导入方法依赖的package包/类
/**
    * Get a locker for a writable operation, also specifying whether to retain
    * non-transactional locks when a new locker must be created.
    *
    * @param retainNonTxnLocks is true for DbTree operations, so that the
    * handle lock may be transferred out of the locker when the operation is
    * complete.
    */
   public static Locker getWritableLocker(Environment env,
                                          Transaction userTxn,
                                          boolean dbIsTransactional,
                                          boolean retainNonTxnLocks,
                                          TransactionConfig autoCommitConfig)
       throws DatabaseException {

       EnvironmentImpl envImpl = DbInternal.envGetEnvironmentImpl(env);
       boolean envIsTransactional = envImpl.isTransactional();

if (userTxn == null) {
    Transaction xaLocker = env.getThreadTransaction();
    if (xaLocker != null) {
	return DbInternal.getLocker(xaLocker);
    }
}

       if (dbIsTransactional && userTxn == null) {

           if (autoCommitConfig == null) {
               autoCommitConfig = DbInternal.getDefaultTxnConfig(env);
           }
           return new AutoTxn(envImpl, autoCommitConfig);

       } else if (userTxn == null) {

           if (retainNonTxnLocks) {
               return new BasicLocker(envImpl);
           } else {
               return new ThreadLocker(envImpl);
           }

       } else {

           /*
            * The user provided a transaction, the environment and the
            * database had better be opened transactionally.
            */
           if (!envIsTransactional) {
               throw new DatabaseException
	    ("A Transaction cannot be used because the"+
	     " environment was opened" +
	     " non-transactionally");
           }
           if (!dbIsTransactional) {
               throw new DatabaseException
	    ("A Transaction cannot be used because the" +
	     " database was opened" +
	     " non-transactionally");
           }

           /*
            * Use the locker for the given transaction.  For read-comitted,
            * wrap the given transactional locker in a special locker for that
            * isolation level.  But if retainNonTxnLocks we cannot use
            * read-committed, since retainNonTxnLocks is used for handle locks
            * that must be retained across operations.
            */
           Locker locker = DbInternal.getLocker(userTxn);
           if (locker.isReadCommittedIsolation() && !retainNonTxnLocks) {
               return new ReadCommittedLocker(envImpl, locker);
           } else {
               return locker;
           }
       }
   }
 

import com.sleepycat.je.Environment; //导入方法依赖的package包/类
/**
    * Get a locker for a read or cursor operation.
    * See getWritableLocker for an explanation of retainNonTxnLocks.
    */
   private static Locker getReadableLocker(Environment env,
                                           Locker locker,
                                           boolean retainNonTxnLocks,
                                           boolean readCommittedIsolation)
       throws DatabaseException {

       EnvironmentImpl envImpl = DbInternal.envGetEnvironmentImpl(env);

if (locker == null) {
    Transaction xaTxn = env.getThreadTransaction();
    if (xaTxn != null) {
	return DbInternal.getLocker(xaTxn);
    }
}

       if (locker == null) {

           /*
            * A non-transactional locker is requested.  If we're retaining
            * non-transactional locks across operations, use a BasicLocker
            * since the locker may be used across threads; this is used when
            * acquiring handle locks internally (open, close, remove, etc).
            * Otherwise, use a ThreadLocker to avoid self-deadlocks within the
            * same thread; this used for ordinary user operations.
            */
           if (retainNonTxnLocks) {
               locker = new BasicLocker(envImpl);
           } else {
               locker = new ThreadLocker(envImpl);
           }
       } else {

           /*
            * Use the given locker.  For read-committed, wrap the given
            * transactional locker in a special locker for that isolation
            * level.  But if retainNonTxnLocks we cannot use read-committed,
            * since retainNonTxnLocks is used for handle locks that must be
            * retained across operations.
            */
           if (readCommittedIsolation && !retainNonTxnLocks) {
               locker = new ReadCommittedLocker(envImpl, locker);
           }
       }
       return locker;
   }
 

import com.sleepycat.je.Environment; //导入方法依赖的package包/类
/**
    * Get a locker for a writable operation, also specifying whether to retain
    * non-transactional locks when a new locker must be created.
    *
    * @param retainNonTxnLocks is true for DbTree operations, so that the
    * handle lock may be transferred out of the locker when the operation is
    * complete.
    */
   public static Locker getWritableLocker(Environment env,
                                          Transaction userTxn,
                                          boolean dbIsTransactional,
                                          boolean retainNonTxnLocks,
                                          TransactionConfig autoCommitConfig)
       throws DatabaseException {

       EnvironmentImpl envImpl = DbInternal.envGetEnvironmentImpl(env);
       boolean envIsTransactional = envImpl.isTransactional();

if (userTxn == null) {
    Transaction xaLocker = env.getThreadTransaction();
    if (xaLocker != null) {
	return DbInternal.getLocker(xaLocker);
    }
}

       if (dbIsTransactional && userTxn == null) {

           if (autoCommitConfig == null) {
               autoCommitConfig = DbInternal.getDefaultTxnConfig(env);
           }
           return new AutoTxn(envImpl, autoCommitConfig);

       } else if (userTxn == null) {

           if (retainNonTxnLocks) {
               return new BasicLocker(envImpl);
           } else {
               return new ThreadLocker(envImpl);
           }

       } else {

           /* 
            * The user provided a transaction, the environment and the
            * database had better be opened transactionally.
            */
           if (!envIsTransactional) {
               throw new DatabaseException
	    ("A Transaction cannot be used because the"+
	     " environment was opened" +
	     " non-transactionally");
           }
           if (!dbIsTransactional) {
               throw new DatabaseException
	    ("A Transaction cannot be used because the" +
	     " database was opened" +
	     " non-transactionally");
           }

           /*
            * Use the locker for the given transaction.  For read-comitted,
            * wrap the given transactional locker in a special locker for that
            * isolation level.  But if retainNonTxnLocks we cannot use
            * read-committed, since retainNonTxnLocks is used for handle locks
            * that must be retained across operations.
            */
           Locker locker = DbInternal.getLocker(userTxn);
           if (locker.isReadCommittedIsolation() && !retainNonTxnLocks) {
               return new ReadCommittedLocker(envImpl, locker);
           } else {
               return locker;
           }
       }
   }
 

import com.sleepycat.je.Environment; //导入方法依赖的package包/类
/**
    * Get a locker for a read or cursor operation.
    * See getWritableLocker for an explanation of retainNonTxnLocks.
    */
   private static Locker getReadableLocker(Environment env,
                                           Locker locker,
                                           boolean retainNonTxnLocks,
                                           boolean readCommittedIsolation) 
       throws DatabaseException {

       EnvironmentImpl envImpl = DbInternal.envGetEnvironmentImpl(env);

if (locker == null) {
    Transaction xaTxn = env.getThreadTransaction();
    if (xaTxn != null) {
	return DbInternal.getLocker(xaTxn);
    }
}

       if (locker == null) {

           /*
            * A non-transactional locker is requested.  If we're retaining
            * non-transactional locks across operations, use a BasicLocker
            * since the locker may be used across threads; this is used when
            * acquiring handle locks internally (open, close, remove, etc).
            * Otherwise, use a ThreadLocker to avoid self-deadlocks within the
            * same thread; this used for ordinary user operations.
            */
           if (retainNonTxnLocks) {
               locker = new BasicLocker(envImpl);
           } else {
               locker = new ThreadLocker(envImpl);
           }
       } else {

           /*
            * Use the given locker.  For read-committed, wrap the given
            * transactional locker in a special locker for that isolation
            * level.  But if retainNonTxnLocks we cannot use read-committed,
            * since retainNonTxnLocks is used for handle locks that must be
            * retained across operations.
            */
           if (readCommittedIsolation && !retainNonTxnLocks) {
               locker = new ReadCommittedLocker(envImpl, locker);
           }
       }
       return locker;
   }
 

import com.sleepycat.je.Environment; //导入方法依赖的package包/类
public static Transaction getThreadTransaction(Environment env)
    throws DatabaseException {

    return env.getThreadTransaction();
}
 

import com.sleepycat.je.Environment; //导入方法依赖的package包/类
/**
 * Get a locker for a write operation.
 *
 * @param autoTxnIsReplicated is true if this transaction is
 * executed on a rep group master, and needs to be broadcast.
 * Currently, all application-created transactions are of the type
 * com.sleepycat.je.txn.Txn, and are replicated if the parent
 * environment is replicated. Auto Txns are trickier because they may
 * be created for a local write operation, such as log cleaning.
 *
 * @throws IllegalArgumentException via db/cursor read/write methods.
 */
public static Locker getWritableLocker(Environment env,
                                       Transaction userTxn,
                                       boolean isInternalDb,
                                       boolean dbIsTransactional,
                                       boolean autoTxnIsReplicated,
                                       TransactionConfig autoCommitConfig)
    throws DatabaseException {

    EnvironmentImpl envImpl = DbInternal.getEnvironmentImpl(env);
    boolean envIsTransactional = envImpl.isTransactional();

    if (userTxn == null) {
        Transaction xaLocker = env.getThreadTransaction();
        if (xaLocker != null) {
            return DbInternal.getLocker(xaLocker);
        }
    }

    if (dbIsTransactional && userTxn == null) {

        if (autoCommitConfig == null) {
            autoCommitConfig = DbInternal.getDefaultTxnConfig(env);
        }

        return Txn.createAutoTxn(envImpl,
                                 autoCommitConfig,
                                 (autoTxnIsReplicated ?
                                  ReplicationContext.MASTER :
                                  ReplicationContext.NO_REPLICATE));

    } else if (userTxn == null) {
        /* Non-transactional user operations use ThreadLocker. */
        return ThreadLocker.createThreadLocker(envImpl);
    } else {

        /*
         * The user provided a transaction, the environment and the
         * database had better be opened transactionally.
         */
        if (!isInternalDb && !envIsTransactional) {
            throw new IllegalArgumentException
                ("A Transaction cannot be used because the"+
                 " environment was opened non-transactionally");
        }
        if (!dbIsTransactional) {
            throw new IllegalArgumentException
                ("A Transaction cannot be used because the" +
                 " database was opened non-transactionally");
        }

        /*
         * Use the locker for the given transaction.  For read-comitted,
         * wrap the given transactional locker in a special locker for that
         * isolation level.
         */
        Locker locker = DbInternal.getLocker(userTxn);
        if (locker.isReadCommittedIsolation()) {
            return ReadCommittedLocker.
                createReadCommittedLocker(envImpl, locker);
        }
        
        return locker;
    }
}