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; } }