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