void initExisting__wrappee__base(
Environment env, Locker locker, DatabaseImpl databaseImpl, DatabaseConfig dbConfig)
throws DatabaseException {
validateConfigAgainstExistingDb(dbConfig, databaseImpl);
init(env, dbConfig);
this.databaseImpl = databaseImpl;
databaseImpl.addReferringHandle(this);
configuration.setSortedDuplicates(databaseImpl.getSortedDuplicates());
configuration.setTransactional(databaseImpl.isTransactional());
}
/** Open a database, called by Environment. */
void initExisting(
Environment env, Locker locker, DatabaseImpl databaseImpl, DatabaseConfig dbConfig)
throws DatabaseException {
/*
* Make sure the configuration used for the open is compatible with the
* existing databaseImpl.
*/
validateConfigAgainstExistingDb(dbConfig, databaseImpl);
init(env, dbConfig);
this.databaseImpl = databaseImpl;
databaseImpl.addReferringHandle(this);
/*
* Copy the duplicates and transactional properties of the underlying
* database, in case the useExistingConfig property is set.
*/
configuration.setSortedDuplicates(databaseImpl.getSortedDuplicates());
configuration.setTransactional(databaseImpl.isTransactional());
}
/**
* 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;
}
}
@Test
public void testConfigMatching() throws Throwable {
try {
/* DatabaseConfig matching. */
DatabaseConfig confA = new DatabaseConfig();
DatabaseConfig confB = new DatabaseConfig();
try {
confA.validate(confB);
} catch (Exception E) {
fail("expected valid match");
}
try {
confB.validate(confA);
} catch (Exception E) {
fail("expected valid match");
}
try {
confA.validate(null); // uses the DEFAULT config
} catch (Exception E) {
fail("expected valid match");
}
confA.setReadOnly(true);
try {
confA.validate(confB);
fail("expected exception");
} catch (IllegalArgumentException E) {
// ok
}
confA.setReadOnly(false);
confA.setSortedDuplicates(true);
try {
confA.validate(confB);
fail("expected exception");
} catch (IllegalArgumentException E) {
// ok
}
confA.setSortedDuplicates(false);
confA.setOverrideBtreeComparator(true);
confA.setBtreeComparator(TestComparator.class);
confB.setOverrideBtreeComparator(true);
confB.setBtreeComparator(TestComparator2.class);
try {
confA.validate(confB);
fail("expected exception");
} catch (IllegalArgumentException E) {
// ok
}
confA.setBtreeComparator((Class) null);
confA.setOverrideBtreeComparator(false);
confB.setBtreeComparator((Class) null);
confB.setOverrideBtreeComparator(false);
confA.setOverrideDuplicateComparator(true);
confA.setDuplicateComparator(TestComparator.class);
confB.setOverrideDuplicateComparator(true);
confB.setDuplicateComparator(TestComparator2.class);
try {
confA.validate(confB);
fail("expected exception");
} catch (IllegalArgumentException E) {
// ok
}
/* Same tests as above but for serialized comparators. */
confA.setOverrideBtreeComparator(true);
confA.setBtreeComparator(new TestSerialComparator());
confB.setOverrideBtreeComparator(true);
confB.setBtreeComparator(new TestSerialComparator2());
try {
confA.validate(confB);
fail("expected exception");
} catch (IllegalArgumentException E) {
// ok
}
confA.setBtreeComparator((Comparator) null);
confA.setOverrideBtreeComparator(false);
confB.setBtreeComparator((Comparator) null);
confB.setOverrideBtreeComparator(false);
confA.setOverrideDuplicateComparator(true);
confA.setDuplicateComparator(new TestSerialComparator());
confB.setOverrideDuplicateComparator(true);
confB.setDuplicateComparator(new TestSerialComparator2());
try {
confA.validate(confB);
fail("expected exception");
} catch (IllegalArgumentException E) {
// ok
}
/* SecondaryConfig matching. */
SecondaryConfig confC = new SecondaryConfig();
SecondaryConfig confD = new SecondaryConfig();
confC.setKeyCreator(new SecKeyCreator1());
confD.setKeyCreator(new SecKeyCreator1());
try {
confC.validate(confD);
} catch (Exception E) {
E.printStackTrace();
fail("expected valid match");
}
try {
confD.validate(confC);
} catch (Exception E) {
fail("expected valid match");
}
try {
confC.validate(null);
fail("expected exception");
} catch (IllegalArgumentException E) {
// ok
}
confD.setKeyCreator(new SecKeyCreator2());
try {
confC.validate(confD);
fail("expected exception");
} catch (IllegalArgumentException E) {
// ok
}
confD.setKeyCreator(new SecKeyCreator1());
confD.setMultiKeyCreator(new SecMultiKeyCreator1());
try {
confC.validate(confD);
fail("expected exception");
} catch (IllegalArgumentException E) {
// ok
}
confD.setMultiKeyCreator(null);
confC.setForeignKeyDeleteAction(ForeignKeyDeleteAction.NULLIFY);
try {
confC.validate(confD);
fail("expected exception");
} catch (IllegalArgumentException E) {
// ok
}
confC.setForeignKeyDeleteAction(ForeignKeyDeleteAction.ABORT);
confC.setForeignKeyNullifier(new ForeignKeyNullifier1());
try {
confC.validate(confD);
fail("expected exception");
} catch (IllegalArgumentException E) {
// ok
}
confC.setForeignKeyNullifier(null);
confC.setForeignMultiKeyNullifier(new ForeignMultiKeyNullifier1());
try {
confC.validate(confD);
fail("expected exception");
} catch (IllegalArgumentException E) {
// ok
}
confC.setForeignMultiKeyNullifier(null);
confC.setImmutableSecondaryKey(true);
try {
confC.validate(confD);
fail("expected exception");
} catch (IllegalArgumentException E) {
// ok
}
confC.setImmutableSecondaryKey(false);
} 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;
}
}
