Java DatabaseNotFoundException类代码示例

import com.sleepycat.je.DatabaseNotFoundException; //导入依赖的package包/类
/**
 * Replica invocations.
 *
 * @see #doRenameDb
 */
public DatabaseImpl renameReplicaDb(Locker locker,
                                    String databaseName,
                                    String newName,
                                    NameLN replicatedLN,
                                    DbOpReplicationContext repContext)
    throws DatabaseNotFoundException {

    try {
        return doRenameDb(locker, databaseName, newName, replicatedLN,
                          repContext);
    } catch (NeedRepLockerException e) {
        /* Should never happen; db is known when locker is created. */
        throw EnvironmentFailureException.unexpectedException(envImpl, e);
    }
}
 

import com.sleepycat.je.DatabaseNotFoundException; //导入依赖的package包/类
/**
 * @see #doTruncateDb
 */
public TruncateDbResult truncateReplicaDb(Locker locker,
                                          String databaseName,
                                          boolean returnCount,
                                          NameLN replicatedLN,
                                          DbOpReplicationContext repContext)
    throws DatabaseNotFoundException {

    try {
        return doTruncateDb(locker, databaseName, returnCount,
                            replicatedLN, repContext);
    } catch (NeedRepLockerException e) {
        /* Should never happen; db is known when locker is created. */
        throw EnvironmentFailureException.unexpectedException(envImpl, e);
    }
}
 

import com.sleepycat.je.DatabaseNotFoundException; //导入依赖的package包/类
/**
 * Stand alone and Master invocations.
 *
 * @see #doRenameDb
 */
public DatabaseImpl dbRename(Locker locker,
                             String databaseName,
                             String newName)
    throws DatabaseNotFoundException, NeedRepLockerException {

    return doRenameDb(locker, databaseName, newName, null, null);
}
 

import com.sleepycat.je.DatabaseNotFoundException; //导入依赖的package包/类
/**
 * Stand alone and Master invocations.
 *
 * @see #doRemoveDb
 */
public DatabaseImpl dbRemove(Locker locker,
                     String databaseName,
                     DatabaseId checkId)
    throws DatabaseNotFoundException, NeedRepLockerException {

    return doRemoveDb(locker, databaseName, checkId, null);
}
 

import com.sleepycat.je.DatabaseNotFoundException; //导入依赖的package包/类
/**
 * Replica invocations.
 *
 * @see #doRemoveDb
 */
public void removeReplicaDb(Locker locker,
                            String databaseName,
                            DatabaseId checkId,
                            DbOpReplicationContext repContext)
    throws DatabaseNotFoundException {

    try {
        doRemoveDb(locker, databaseName, checkId, repContext);
    } catch (NeedRepLockerException e) {
        /* Should never happen; db is known when locker is created. */
        throw EnvironmentFailureException.unexpectedException(envImpl, e);
    }
}
 

import com.sleepycat.je.DatabaseNotFoundException; //导入依赖的package包/类
/**
 * @see #doTruncateDb
 */
public TruncateDbResult truncate(Locker locker,
                                 String databaseName,
                                 boolean returnCount)
    throws DatabaseNotFoundException, NeedRepLockerException {

    return doTruncateDb(locker, databaseName, returnCount, null, null);
}
 

import com.sleepycat.je.DatabaseNotFoundException; //导入依赖的package包/类
/**
 * Helper to get statistics for a given database.
 * @param params operation parameters
 * @return DatabaseStats object
 */
private DatabaseStats getDatabaseStats(Environment targetEnv,
                                       Object[] params)
    throws IllegalArgumentException,
           DatabaseNotFoundException,
           DatabaseException {

    if ((params == null) || (params.length < 3)) {
        return null;
    }
    String dbName = (String)params[2];

    Database db = null;
    try {
        DatabaseConfig dbConfig = new DatabaseConfig();
        dbConfig.setReadOnly(true);
        DbInternal.setUseExistingConfig(dbConfig, true);
        try {
            db = targetEnv.openDatabase(null, dbName, dbConfig);
        } catch (DatabaseExistsException e) {
            /* Should never happen, ExlcusiveCreate is false. */
            throw EnvironmentFailureException.unexpectedException(e);
        }
        return db.getStats(getStatsConfig(params));
    } finally {
        if (db != null) {
            db.close();
        }
    }
}
 

import com.sleepycat.je.DatabaseNotFoundException; //导入依赖的package包/类
/**
 * Returns all the members that are currently part of the replication
 * group. This method can read the database directly, and can be used when
 * the replicated environment is detached and the RepNode is null. It's for
 * the latter reason that the method reads uncommitted data. In detached
 * mode, there may be transactions on the database that were in progress
 * when the node was last shutdown. These transactions may have locks which
 * will not be released until after the node is re-attached and the
 * replication stream is resumed. Using uncommitted reads avoids use of
 * locks in this circumstance. It's safe to read these records, since the
 * database will eventually be updated with these changes.
 *
 * @param policy determines how current the information must be if it's
 * invoked on a Replica.
 *
 * @return the group object
 * @throws DatabaseException if the object could not be obtained
 */
public static RepGroupImpl getGroup(RepImpl rImpl,
                                    String groupName,
                                    ReplicaConsistencyPolicy policy)
    throws DatabaseException {

    DatabaseImpl dbImpl = null;
    try {
        dbImpl = rImpl.getGroupDb(policy);
    } catch (DatabaseNotFoundException e) {
        /* Creates a temporary placeholder group for use until the real
         * definition comes over the replication stream as part of the
         * replicated group database.
         */
        return new RepGroupImpl(groupName, true);
    }

    TransactionConfig txnConfig = new TransactionConfig();
    txnConfig.setDurability(READ_ONLY.getDurability());
    txnConfig.setConsistencyPolicy(policy);
    txnConfig.setReadUncommitted(true);

    Txn txn = null;
    try {
        txn = new ReadonlyTxn(rImpl, txnConfig);
        RepGroupImpl group = fetchGroup(groupName, dbImpl, txn);
        /* Correct summary info since we are reading uncommitted data */
        group.makeConsistent();
        txn.commit();
        txn = null;

        return group;
    } finally {
        if (txn != null) {
            txn.abort();
        }
    }
}
 

import com.sleepycat.je.DatabaseNotFoundException; //导入依赖的package包/类
private TwoPhaseUpdate(RepNodeImpl node) {
    super();
    this.node = node;
    try {
        groupDbImpl = repImpl.getGroupDb();
    } catch (DatabaseNotFoundException e) {
        /* Should never happen. */
        throw EnvironmentFailureException.unexpectedException(e);
    }
}
 

import com.sleepycat.je.DatabaseNotFoundException; //导入依赖的package包/类
/**
 * Open the group db, which should exist already. Do not wait on the
 * group db lock, return null if the databaseImpl hasn't been created and
 * we can't obtain it.
 *
 * Lock hierarchy: GroupDbLock -> sync on EnvironmentImpl
 */
public DatabaseImpl probeGroupDb()
    throws DatabaseException {

    try {
        return openGroupDb(NO_CONSISTENCY, true /* doLockProbe */);
    } catch (DatabaseNotFoundException e) {
        /* Should never happen, DB should exist. */
        throw EnvironmentFailureException.unexpectedException(e);
    }
}
 

import com.sleepycat.je.DatabaseNotFoundException; //导入依赖的package包/类
public void initInternalStructure(DatabaseSession databaseSession) throws BimserverLockConflictException, BimserverDatabaseException {
	RecordIterator recordIterator = keyValueStore.getRecordIterator(CLASS_LOOKUP_TABLE, databaseSession);
	try {
		Record record = recordIterator.next();
		while (record != null) {
			String packageAndClassName = BinUtils.byteArrayToString(record.getValue());
			String packageName = packageAndClassName.substring(0, packageAndClassName.indexOf("_"));
			String className = packageAndClassName.substring(packageAndClassName.indexOf("_") + 1);
			EClass eClass = (EClass) getEClassifier(packageName, className);
			
			// TODO geometry?
			boolean transactional = !(eClass.getEPackage() == Ifc2x3tc1Package.eINSTANCE || eClass.getEPackage() == Ifc4Package.eINSTANCE);

			keyValueStore.openTable(databaseSession, packageAndClassName, transactional);
			
			for (EStructuralFeature eStructuralFeature : eClass.getEAllStructuralFeatures()) {
				if (eStructuralFeature.getEAnnotation("singleindex") != null) {
					String indexTableName = eClass.getEPackage().getName() + "_" + eClass.getName() + "_" + eStructuralFeature.getName();
					try {
						keyValueStore.openIndexTable(databaseSession, indexTableName, transactional);
					} catch (DatabaseNotFoundException e) {
					}
				}
			}
			
			Short cid = BinUtils.byteArrayToShort(record.getKey());
			cidToEclass[cid] = eClass;
			eClassToCid.put(eClass, cid);
			record = recordIterator.next();
		}
	} finally {
		recordIterator.close();
	}
}
 

import com.sleepycat.je.DatabaseNotFoundException; //导入依赖的package包/类
/**
 * true if there is a persistent database underlying this, otherwise false
 * 
 * @return true if there is a persistent database underlying this, otherwise false
 */
public boolean exists() {
	try {
		getDatabase(true) ;
	} catch(DatabaseNotFoundException e) {
		return false ;
	}
	return true ;
}
 

import com.sleepycat.je.DatabaseNotFoundException; //导入依赖的package包/类
protected Database getDatabase(boolean readOnly) throws DatabaseException {
	
	DatabaseConfig conf = new DatabaseConfig() ;
	
	conf.setReadOnly(readOnly) ;
	conf.setAllowCreate(!readOnly) ;
	conf.setExclusiveCreate(!readOnly) ;

	if (database != null) {
		if (database.getConfig().getReadOnly() == readOnly) {
			//the database is already open as it should be.
			return database ;
		} else {
			//the database needs to be closed and re-opened.
			database.close();
		}
	}
	
	if (!readOnly) {
		try {
			env.getEnvironment().removeDatabase(null, name) ;
		} catch (DatabaseNotFoundException e) {} ;
	}
	
	database = env.getEnvironment().openDatabase(null, name, conf);
	return database ;
}
 

import com.sleepycat.je.DatabaseNotFoundException; //导入依赖的package包/类
/**
 * @see Environment#openDatabase(Transaction, String, DatabaseConfig)
 */
public synchronized Database openDatabase(Transaction txn, String databaseName, DatabaseConfig dbConfig)
        throws DatabaseNotFoundException, DatabaseExistsException, IllegalArgumentException, IllegalStateException {
    return delegate().openDatabase(txn, databaseName, dbConfig);
}
 

import com.sleepycat.je.DatabaseNotFoundException; //导入依赖的package包/类
/**
 * @see Environment#openSecondaryDatabase(Transaction, String, Database, SecondaryConfig)
 */
public synchronized SecondaryDatabase openSecondaryDatabase(Transaction txn, String databaseName, 
        Database primaryDatabase, SecondaryConfig dbConfig) throws DatabaseNotFoundException, DatabaseExistsException,
        DatabaseException, IllegalArgumentException, IllegalStateException {
    return delegate().openSecondaryDatabase(txn, databaseName, primaryDatabase, dbConfig);
}