/* Test mutable and persistent configurations. */
@Test
public void testPersistentAndMutableConfigs() throws Exception {
final String dbName = "foo";
EnvironmentConfig envConfig = TestUtils.initEnvConfig();
envConfig.setAllowCreate(true);
envConfig.setTransactional(true);
env = create(envHome, envConfig);
DbConfigManager configMgr = DbInternal.getEnvironmentImpl(env).getConfigManager();
int defaultNodeMaxEntries = configMgr.getInt(EnvironmentParams.NODE_MAX);
int defaultNodeDupTreeMaxEntries = configMgr.getInt(EnvironmentParams.NODE_MAX_DUPTREE);
/* Check the default node max entries setting. */
assertEquals(defaultNodeMaxEntries, 128);
assertEquals(defaultNodeDupTreeMaxEntries, 128);
DatabaseConfig dbConfig = new DatabaseConfig();
dbConfig.setAllowCreate(true);
dbConfig.setTransactional(true);
/* Do updates on each persistent and mutable config. */
/* Check whether BtreeComparator setting is persisted. */
dbConfig.setOverrideBtreeComparator(true);
dbConfig.setBtreeComparator(TestComparator.class);
DatabaseConfig newConfig = setAndGetDbConfig(env, dbConfig, dbName);
assertTrue(newConfig.getBtreeComparator() instanceof TestComparator);
/* Check whether DuplicateComparator setting is persisted. */
dbConfig.setOverrideDuplicateComparator(true);
dbConfig.setDuplicateComparator(new TestSerialComparator());
newConfig = setAndGetDbConfig(env, dbConfig, dbName);
assertTrue(newConfig.getDuplicateComparator() instanceof TestSerialComparator);
/* Check whether KeyPrefixing setting is persisted. */
dbConfig.setKeyPrefixing(true);
newConfig = setAndGetDbConfig(env, dbConfig, dbName);
assertTrue(newConfig.getKeyPrefixing());
/* Check whether NodeMaxEntries setting is persisted. */
dbConfig.setNodeMaxEntries(512);
newConfig = setAndGetDbConfig(env, dbConfig, dbName);
assertTrue(newConfig.getNodeMaxEntries() == 512);
close(env);
}
/**
* 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;
}
}
