/** Test exclusive creation. */
@Test
public void testExclusive() throws Throwable {
try {
EnvironmentConfig envConfig = TestUtils.initEnvConfig();
/*
* Make sure that the database keeps its own copy of the
* configuration object.
*/
envConfig.setAllowCreate(true);
env = create(envHome, envConfig);
DatabaseConfig dbConfig = new DatabaseConfig();
dbConfig.setAllowCreate(true);
dbConfig.setExclusiveCreate(true);
/* Should succeed and create the database. */
Database dbA = env.openDatabase(null, "foo", dbConfig);
dbA.close();
/* Should not succeed, because the database exists. */
try {
env.openDatabase(null, "foo", dbConfig);
fail("Database already exists");
} catch (DatabaseException e) {
}
close(env);
} catch (Throwable t) {
t.printStackTrace();
throw t;
}
}
public BDBCreator(String tableName, ArrayList<Integer> keyPositions, int secondaryIndex) {
/* Creates and loads a BDB table with a secondary index on the column defined by*/
this.tableName = tableName.toLowerCase();
this.keyPositions = keyPositions;
this.secIndexPos = secondaryIndex;
this.tMap = Main.indexTypeMaps.get(this.tableName);
setEnvironment();
dbConfig = new DatabaseConfig();
dbConfig.setAllowCreate(true);
myDB = myDbEnvironment.openDatabase(null, this.tableName, dbConfig);
SecondaryConfig secConfig = new SecondaryConfig();
secConfig.setAllowCreate(true);
secConfig.setSortedDuplicates(true);
createSecDB(secConfig);
setConfig(dbConfig, secConfig);
loadData();
if (secDB != null) {
secDB.close();
}
if (myDB != null) {
myDB.close();
}
closeEnvironment();
}
public WorkQueues(Environment env, String dbName, boolean resumable) throws DatabaseException {
this.env = env;
this.resumable = resumable;
DatabaseConfig dbConfig = new DatabaseConfig();
dbConfig.setAllowCreate(true);
dbConfig.setTransactional(resumable);
dbConfig.setDeferredWrite(!resumable);
urlsDB = env.openDatabase(null, dbName, dbConfig);
webURLBinding = new WebURLTupleBinding();
}
/*
* This method will:
* 1. apply the modified DatabaseConfig to the database.
* 2. close the database and do a sync to make sure the new configuration
* is written to the log.
* 3. open the database with a useExisting config and return the current
* DatabaseConfig.
*/
private DatabaseConfig setAndGetDbConfig(Environment env, DatabaseConfig dbConfig, String dbName)
throws Exception {
Database db = env.openDatabase(null, "foo", dbConfig);
db.close();
env.sync();
/*
* Open with the useExisting config to see what attributes have been
* persisted.
*/
DatabaseConfig newConfig = new DatabaseConfig();
newConfig.setReadOnly(true);
newConfig.setTransactional(true);
newConfig.setUseExistingConfig(true);
db = env.openDatabase(null, dbName, newConfig);
newConfig = db.getConfig();
db.close();
return newConfig;
}
public BDBCreator(String tableName, ArrayList<Integer> keyPositions) {
/* Creates and loads a BDB table without a secondary index*/
this.tableName = tableName.toLowerCase();
this.keyPositions = keyPositions;
this.tMap = Main.indexTypeMaps.get(this.tableName);
setEnvironment();
dbConfig = new DatabaseConfig();
dbConfig.setAllowCreate(true);
myDB = myDbEnvironment.openDatabase(null, this.tableName, dbConfig);
loadData();
if (myDB != null) {
myDB.close();
}
closeEnvironment();
}
/**
* Test that we can retrieve a database configuration and that it clones its configuration
* appropriately.
*/
@Test
public void testConfig() throws Throwable {
try {
EnvironmentConfig envConfig = TestUtils.initEnvConfig();
envConfig.setAllowCreate(true);
env = create(envHome, envConfig);
/*
* Make sure that the database keeps its own copy of the
* configuration object.
*/
DatabaseConfig dbConfigA = new DatabaseConfig();
dbConfigA.setAllowCreate(true);
Database dbA = env.openDatabase(null, "foo", dbConfigA);
/* Change the original dbConfig */
dbConfigA.setAllowCreate(false);
DatabaseConfig getConfig1 = dbA.getConfig();
assertEquals(true, getConfig1.getAllowCreate());
assertEquals(false, getConfig1.getSortedDuplicates());
/*
* Change the retrieved config, ought to have no effect on what the
* Database is storing.
*/
getConfig1.setSortedDuplicates(true);
DatabaseConfig getConfig2 = dbA.getConfig();
assertEquals(false, getConfig2.getSortedDuplicates());
dbA.close();
close(env);
} catch (Throwable t) {
t.printStackTrace();
throw t;
}
}
public static void main(String[] args) {
Environment myEnv;
Database myDatabase;
try {
EnvironmentConfig envConfig = new EnvironmentConfig();
envConfig.setAllowCreate(true);
myEnv = new Environment(new File("/Users/broso/testDB"), envConfig);
// Environment open omitted for clarity
DatabaseConfig myDbConfig = new DatabaseConfig();
SecondaryConfig mySecConfig = new SecondaryConfig();
myDbConfig.setAllowCreate(true);
mySecConfig.setAllowCreate(true);
// Duplicates are frequently required for secondary databases.
mySecConfig.setSortedDuplicates(true);
// Open the primary
String dbName = "myPrimaryDatabase";
Database myDb = myEnv.openDatabase(null, dbName, myDbConfig);
// Open the secondary.
// Key creators are described in the next section.
// AKeyCreator akc = new AKeyCreator();
// Get a secondary object and set the key creator on it.
// mySecConfig.setKeyCreator(keyCreator);
// Perform the actual open
String secDbName = "mySecondaryDatabase";
SecondaryDatabase mySecDb = myEnv.openSecondaryDatabase(null, secDbName, myDb, mySecConfig);
} catch (DatabaseException de) {
// Exception handling goes here
}
}
/*
* Test that changing the Btree comparator really writes it to disk.
*/
@Test
public void testConfigOverrideUpdateSR15743() throws Throwable {
try {
EnvironmentConfig envConfig = TestUtils.initEnvConfig();
envConfig.setAllowCreate(true);
env = create(envHome, envConfig);
/*
* Make sure that the database keeps its own copy of the
* configuration object.
*/
DatabaseConfig dbConfigA = new DatabaseConfig();
dbConfigA.setOverrideBtreeComparator(false);
dbConfigA.setBtreeComparator(TestComparator.class);
dbConfigA.setAllowCreate(true);
Database dbA = env.openDatabase(null, "foo", dbConfigA);
/* Change the original dbConfig */
dbConfigA.setBtreeComparator(TestComparator2.class);
DatabaseConfig getConfig1 = dbA.getConfig();
assertEquals(TestComparator.class, getConfig1.getBtreeComparator().getClass());
/*
* Change the retrieved config, ought to have no effect on what the
* Database is storing.
*/
getConfig1.setBtreeComparator(TestComparator2.class);
DatabaseConfig getConfig2 = dbA.getConfig();
assertEquals(TestComparator.class, getConfig2.getBtreeComparator().getClass());
dbA.close();
close(env);
/* Ensure new comparator is written to disk. */
envConfig = TestUtils.initEnvConfig();
env = create(envHome, envConfig);
dbConfigA = new DatabaseConfig();
/* Change the comparator. */
dbConfigA.setOverrideBtreeComparator(true);
dbConfigA.setBtreeComparator(TestComparator2.class);
dbA = env.openDatabase(null, "foo", dbConfigA);
getConfig2 = dbA.getConfig();
assertEquals(TestComparator2.class, getConfig2.getBtreeComparator().getClass());
dbA.close();
close(env);
/* Read it back during recovery to ensure it was written. */
envConfig = TestUtils.initEnvConfig();
env = create(envHome, envConfig);
dbConfigA = new DatabaseConfig();
dbA = env.openDatabase(null, "foo", dbConfigA);
getConfig2 = dbA.getConfig();
assertEquals(TestComparator2.class, getConfig2.getBtreeComparator().getClass());
/* Create a root for the tree. */
dbA.put(null, new DatabaseEntry(new byte[1]), new DatabaseEntry(new byte[1]));
dbA.close();
close(env);
/* Change it to a third one when there is a root present. */
envConfig = TestUtils.initEnvConfig();
env = create(envHome, envConfig);
dbConfigA = new DatabaseConfig();
/* Change the comparator. */
dbConfigA.setOverrideBtreeComparator(true);
dbConfigA.setBtreeComparator(TestComparator3.class);
dbA = env.openDatabase(null, "foo", dbConfigA);
getConfig2 = dbA.getConfig();
assertEquals(TestComparator3.class, getConfig2.getBtreeComparator().getClass());
dbA.close();
close(env);
/* Read it back during recovery to ensure it was written. */
envConfig = TestUtils.initEnvConfig();
env = create(envHome, envConfig);
dbConfigA = new DatabaseConfig();
dbA = env.openDatabase(null, "foo", dbConfigA);
getConfig2 = dbA.getConfig();
assertEquals(TestComparator3.class, getConfig2.getBtreeComparator().getClass());
dbA.close();
close(env);
} catch (Throwable t) {
t.printStackTrace();
throw t;
}
}
@Test
public void testOpenReadOnly() throws Throwable {
try {
EnvironmentConfig envConfig = TestUtils.initEnvConfig();
envConfig.setTransactional(true);
envConfig.setAllowCreate(true);
env = create(envHome, envConfig);
DatabaseEntry key = new DatabaseEntry();
DatabaseEntry data = new DatabaseEntry();
Transaction txn = env.beginTransaction(null, null);
DatabaseConfig dbConfig = new DatabaseConfig();
dbConfig.setTransactional(true);
dbConfig.setAllowCreate(true);
Database myDb = env.openDatabase(txn, "testDB2", dbConfig);
key.setData(TestUtils.getTestArray(0));
data.setData(TestUtils.getTestArray(0));
try {
myDb.put(txn, key, data);
} catch (DatabaseException DBE) {
fail("unexpected DatabaseException during put");
}
txn.commit();
myDb.close();
dbConfig = new DatabaseConfig();
dbConfig.setTransactional(true);
dbConfig.setReadOnly(true);
txn = env.beginTransaction(null, null);
myDb = env.openDatabase(txn, "testDB2", dbConfig);
assertTrue(myDb.isTransactional());
assertTrue(myDb.getConfig().getTransactional());
key.setData(TestUtils.getTestArray(0));
data.setData(TestUtils.getTestArray(0));
try {
myDb.put(txn, key, data);
fail("expected UnsupportedOperationException " + "because open RDONLY");
} catch (UnsupportedOperationException expected) {
}
key.setData(TestUtils.getTestArray(0));
data.setData(TestUtils.getTestArray(0));
assertEquals(OperationStatus.SUCCESS, myDb.get(txn, key, data, LockMode.DEFAULT));
Cursor cursor = myDb.openCursor(txn, null);
assertEquals(OperationStatus.SUCCESS, cursor.getFirst(key, data, LockMode.DEFAULT));
try {
cursor.delete();
fail("expected Exception from delete on RD_ONLY db");
} catch (UnsupportedOperationException e) {
}
key.setData(TestUtils.getTestArray(1));
data.setData(TestUtils.getTestArray(1));
try {
myDb.put(txn, key, data);
fail("expected UnsupportedOperationException because open RDONLY");
} catch (UnsupportedOperationException expected) {
}
cursor.close();
txn.commit();
myDb.close();
close(env);
} catch (Throwable t) {
t.printStackTrace();
throw t;
}
}
@Test
public void testIsTransactional() throws Throwable {
try {
/* Open environment in transactional mode.*/
EnvironmentConfig envConfig = TestUtils.initEnvConfig();
envConfig.setTransactional(true);
envConfig.setAllowCreate(true);
env = create(envHome, envConfig);
/* Create a db, open transactionally with implied auto-commit. */
DatabaseConfig dbConfig = new DatabaseConfig();
dbConfig.setAllowCreate(true);
dbConfig.setTransactional(true);
Database myDb = env.openDatabase(null, "testDB", dbConfig);
assertTrue(myDb.isTransactional());
assertTrue(myDb.getConfig().getTransactional());
myDb.close();
/* Open an existing db, can open it non-transactionally. */
dbConfig.setTransactional(false);
myDb = env.openDatabase(null, "testDB", null);
assertFalse(myDb.isTransactional());
assertFalse(myDb.getConfig().getTransactional());
myDb.close();
/* Open another db, pass an explicit transaction. */
dbConfig.setTransactional(true);
Transaction txn = env.beginTransaction(null, null);
myDb = env.openDatabase(txn, "testDB2", dbConfig);
assertTrue(myDb.isTransactional());
assertTrue(myDb.getConfig().getTransactional());
DatabaseEntry key = new DatabaseEntry();
DatabaseEntry data = new DatabaseEntry();
key.setData(TestUtils.getTestArray(0));
data.setData(TestUtils.getTestArray(0));
try {
myDb.put(null, key, data);
} catch (DatabaseException DBE) {
fail("didn't expect DatabaseException, implied autocommit");
}
key.setData(TestUtils.getTestArray(1));
data.setData(TestUtils.getTestArray(1));
try {
myDb.put(txn, key, data);
} catch (DatabaseException DBE) {
fail("didn't expect DatabaseException with txn passed");
}
try {
myDb.get(txn, key, data, LockMode.DEFAULT);
} catch (DatabaseException DBE) {
fail("didn't expect DatabaseException with txn passed");
}
txn.commit();
try {
myDb.get(null, key, data, LockMode.DEFAULT);
} catch (DatabaseException DBE) {
fail("didn't expect DatabaseException because no txn passed");
}
myDb.close();
close(env);
} catch (Throwable t) {
t.printStackTrace();
throw t;
}
}
/**
* Test that any conflicts between configuration object settings and the underlying impl object
* are detected.
*/
@Test
public void testConfigConflict() throws Throwable {
try {
EnvironmentConfig envConfig = TestUtils.initEnvConfig();
envConfig.setAllowCreate(true);
env = create(envHome, envConfig);
/*
* Test conflicts of duplicate allowed configuration.
*/
/* 1a. Create allowing duplicates. */
DatabaseConfig firstConfig = new DatabaseConfig();
firstConfig.setAllowCreate(true);
firstConfig.setSortedDuplicates(true);
Database firstHandle = env.openDatabase(null, "fooDups", firstConfig);
/* 1b. Try to open w/no duplicates. */
DatabaseConfig secondConfig = new DatabaseConfig();
secondConfig.setSortedDuplicates(false);
try {
env.openDatabase(null, "fooDups", secondConfig);
fail("Conflict in duplicates allowed should be detected.");
} catch (IllegalArgumentException expected) {
}
firstHandle.close();
env.removeDatabase(null, "fooDups");
/* 2a. Create dis-allowing duplicates. */
firstConfig.setSortedDuplicates(false);
firstConfig.setKeyPrefixing(false);
firstHandle = env.openDatabase(null, "fooDups", firstConfig);
/* 2b. Try to open w/duplicates. */
secondConfig.setSortedDuplicates(true);
try {
env.openDatabase(null, "fooDups", secondConfig);
fail("Conflict in duplicates allowed should be detected.");
} catch (IllegalArgumentException expected) {
}
firstHandle.close();
/*
* Test conflicts of read only. If the environment is read/write
* we should be able to open handles in read only or read/write
* mode. If the environment is readonly, the database handles
* must also be read only.
*/
DatabaseConfig readOnlyConfig = new DatabaseConfig();
readOnlyConfig.setReadOnly(true);
Database roHandle = env.openDatabase(null, "fooDups", readOnlyConfig);
roHandle.close();
/* Open the environment in read only mode. */
close(env);
envConfig = TestUtils.initEnvConfig();
envConfig.setReadOnly(true);
env = create(envHome, envConfig);
/* Open a readOnly database handle, should succeed */
roHandle = env.openDatabase(null, "fooDups", readOnlyConfig);
roHandle.close();
/* Open a read/write database handle, should not succeed. */
try {
env.openDatabase(null, "fooDups", null);
fail("Should not be able to open read/write");
} catch (IllegalArgumentException expected) {
}
close(env);
/*
* Check comparator changes.
*/
/* 1a. Open w/a null comparator */
env = create(envHome, null);
firstConfig = new DatabaseConfig();
firstConfig.setAllowCreate(true);
firstHandle = env.openDatabase(null, "fooComparator", firstConfig);
DatabaseConfig firstRetrievedConfig = firstHandle.getConfig();
assertEquals(null, firstRetrievedConfig.getBtreeComparator());
assertEquals(null, firstRetrievedConfig.getDuplicateComparator());
/*
* 1b. Open a db w/a different comparator, shouldn't take effect
* because override is not set.
*/
secondConfig = new DatabaseConfig();
Comparator btreeComparator = new TestComparator();
Comparator dupComparator = new TestComparator();
secondConfig.setBtreeComparator((Class<Comparator<byte[]>>) btreeComparator.getClass());
secondConfig.setDuplicateComparator((Class<Comparator<byte[]>>) dupComparator.getClass());
Database secondHandle = env.openDatabase(null, "fooComparator", secondConfig);
DatabaseConfig retrievedConfig = secondHandle.getConfig();
assertEquals(null, retrievedConfig.getBtreeComparator());
assertEquals(null, retrievedConfig.getDuplicateComparator());
secondHandle.close();
/* Same as above but with a serialized comparator. */
secondConfig = new DatabaseConfig();
btreeComparator = new TestSerialComparator();
dupComparator = new TestSerialComparator();
secondConfig.setBtreeComparator(btreeComparator);
secondConfig.setDuplicateComparator(dupComparator);
secondHandle = env.openDatabase(null, "fooComparator", secondConfig);
retrievedConfig = secondHandle.getConfig();
assertEquals(null, retrievedConfig.getBtreeComparator());
assertEquals(null, retrievedConfig.getDuplicateComparator());
secondHandle.close();
/*
* Test that update DatabaseConfig while there are open handles
* should throw exceptions.
*/
secondConfig.setOverrideBtreeComparator(true);
secondConfig.setOverrideDuplicateComparator(true);
btreeComparator = new TestComparator();
dupComparator = new TestComparator();
secondConfig.setBtreeComparator((Class<Comparator<byte[]>>) btreeComparator.getClass());
secondConfig.setDuplicateComparator((Class<Comparator<byte[]>>) dupComparator.getClass());
try {
secondHandle = env.openDatabase(null, "fooComparator", secondConfig);
fail("Expect exceptions here");
} catch (IllegalStateException e) {
/* Expected exception. */
} catch (Exception e) {
fail("Unexpected exception: " + e.getMessage());
}
secondHandle.close();
/*
* Open a new database handle without DatabaseConfig changes should
* be valid.
*/
try {
secondHandle = env.openDatabase(null, "fooComparator", firstConfig);
} catch (Exception e) {
fail("Unexpected exception: " + e.getMessage());
}
secondHandle.close();
firstHandle.close();
close(env);
} catch (Throwable t) {
t.printStackTrace();
close(env);
throw t;
}
}
/** Test open and close of an environment. */
public void testCacheStats() throws DatabaseException {
EnvironmentConfig envConfig = TestUtils.initEnvConfig();
envConfig.setTransactional(true);
envConfig.setConfigParam(EnvironmentParams.NODE_MAX.getName(), "6");
envConfig.setAllowCreate(true);
env = new Environment(envHome, envConfig);
EnvironmentStats stat = env.getStats(TestUtils.FAST_STATS);
env.close();
env = null;
assertEquals(0, stat.getNCacheMiss());
assertEquals(0, stat.getNNotResident());
// Try to open and close again, now that the environment exists
envConfig.setAllowCreate(false);
envConfig.setConfigParam(EnvironmentParams.JE_LOGGING_LEVEL.getName(), "CONFIG");
env = new Environment(envHome, envConfig);
DatabaseConfig dbConfig = new DatabaseConfig();
dbConfig.setTransactional(true);
dbConfig.setAllowCreate(true);
Database db = env.openDatabase(null, "foo", dbConfig);
db.put(null, new DatabaseEntry(new byte[0]), new DatabaseEntry(new byte[0]));
Transaction txn = env.beginTransaction(null, null);
db.put(txn, new DatabaseEntry(new byte[0]), new DatabaseEntry(new byte[0]));
stat = env.getStats(TestUtils.FAST_STATS);
MemoryBudget mb = DbInternal.envGetEnvironmentImpl(env).getMemoryBudget();
assertEquals(mb.getCacheMemoryUsage(), stat.getCacheTotalBytes());
assertEquals(mb.getLogBufferBudget(), stat.getBufferBytes());
assertEquals(mb.getTreeMemoryUsage() + mb.getTreeAdminMemoryUsage(), stat.getDataBytes());
assertEquals(mb.getLockMemoryUsage(), stat.getLockBytes());
assertEquals(mb.getAdminMemoryUsage(), stat.getAdminBytes());
assertTrue(stat.getBufferBytes() > 0);
assertTrue(stat.getDataBytes() > 0);
assertTrue(stat.getLockBytes() > 0);
assertTrue(stat.getAdminBytes() > 0);
assertEquals(
stat.getCacheTotalBytes(),
stat.getBufferBytes() + stat.getDataBytes() + stat.getLockBytes() + stat.getAdminBytes());
assertEquals(12, stat.getNCacheMiss());
assertEquals(12, stat.getNNotResident());
/* Test deprecated getCacheDataBytes method. */
final EnvironmentStats finalStat = stat;
final long expectCacheDataBytes = mb.getCacheMemoryUsage() - mb.getLogBufferBudget();
(new Runnable() {
@Deprecated
public void run() {
assertEquals(expectCacheDataBytes, finalStat.getCacheDataBytes());
}
})
.run();
txn.abort();
db.close();
env.close();
env = null;
}
//
// Initialize the database to the number of accounts, branches,
// history records, and tellers given to the constructor.
//
public void populate() {
Database dbp = null;
int err;
int balance, idnum;
int end_anum, end_bnum, end_tnum;
int start_anum, start_bnum, start_tnum;
int h_nelem;
idnum = BEGID;
balance = 500000;
h_nelem = accounts;
try {
DatabaseConfig config = new DatabaseConfig();
config.setType(DatabaseType.HASH);
config.setHashNumElements(h_nelem);
config.setAllowCreate(true);
dbp = dbenv.openDatabase(null, "account", null, config);
} catch (Exception e1) {
// can be DatabaseException or FileNotFoundException
errExit(e1, "Open of account file failed");
}
start_anum = idnum;
populateTable(dbp, idnum, balance, h_nelem, "account");
idnum += h_nelem;
end_anum = idnum - 1;
try {
dbp.close();
} catch (DatabaseException e2) {
errExit(e2, "Account file close failed");
}
if (verbose)
System.out.println(
"Populated accounts: " + String.valueOf(start_anum) + " - " + String.valueOf(end_anum));
//
// Since the number of branches is very small, we want to use very
// small pages and only 1 key per page. This is the poor-man's way
// of getting key locking instead of page locking.
//
h_nelem = (int) branches;
try {
DatabaseConfig config = new DatabaseConfig();
config.setType(DatabaseType.HASH);
config.setHashNumElements(h_nelem);
config.setHashFillFactor(1);
config.setPageSize(512);
config.setAllowCreate(true);
dbp = dbenv.openDatabase(null, "branch", null, config);
} catch (Exception e3) {
// can be DatabaseException or FileNotFoundException
errExit(e3, "Branch file create failed");
}
start_bnum = idnum;
populateTable(dbp, idnum, balance, h_nelem, "branch");
idnum += h_nelem;
end_bnum = idnum - 1;
try {
dbp.close();
} catch (DatabaseException dbe4) {
errExit(dbe4, "Close of branch file failed");
}
if (verbose)
System.out.println(
"Populated branches: " + String.valueOf(start_bnum) + " - " + String.valueOf(end_bnum));
//
// In the case of tellers, we also want small pages, but we'll let
// the fill factor dynamically adjust itself.
//
h_nelem = (int) tellers;
try {
DatabaseConfig config = new DatabaseConfig();
config.setType(DatabaseType.HASH);
config.setHashNumElements(h_nelem);
config.setHashFillFactor(0);
config.setPageSize(512);
config.setAllowCreate(true);
dbp = dbenv.openDatabase(null, "teller", null, config);
} catch (Exception e5) {
// can be DatabaseException or FileNotFoundException
errExit(e5, "Teller file create failed");
}
start_tnum = idnum;
populateTable(dbp, idnum, balance, h_nelem, "teller");
idnum += h_nelem;
end_tnum = idnum - 1;
try {
dbp.close();
} catch (DatabaseException e6) {
errExit(e6, "Close of teller file failed");
}
if (verbose)
System.out.println(
"Populated tellers: " + String.valueOf(start_tnum) + " - " + String.valueOf(end_tnum));
try {
DatabaseConfig config = new DatabaseConfig();
config.setType(DatabaseType.RECNO);
config.setRecordLength(HISTORY_LEN);
config.setAllowCreate(true);
dbp = dbenv.openDatabase(null, "history", null, config);
} catch (Exception e7) {
// can be DatabaseException or FileNotFoundException
errExit(e7, "Create of history file failed");
}
populateHistory(dbp);
try {
dbp.close();
} catch (DatabaseException e8) {
errExit(e8, "Close of history file failed");
}
}