public boolean setup(boolean readOnly) { boolean open = false; try { EnvironmentConfig envConfig = new EnvironmentConfig(); envConfig.setReadOnly(readOnly); envConfig.setAllowCreate(!readOnly); env = new Environment(envHome, envConfig); StoreConfig storeConfig = new StoreConfig(); storeConfig.setReadOnly(readOnly); storeConfig.setAllowCreate(!readOnly); store = new EntityStore(env, "EntityStore", storeConfig); objectBySid = store.getPrimaryIndex(String.class, TestObject.class); open = true; } catch (EnvironmentLockedException e) { } catch (Exception e) { e.printStackTrace(); System.exit(-1); } return open; }
private void open() throws DatabaseException { StoreConfig config = new StoreConfig(); config.setAllowCreate(envConfig.getAllowCreate()); config.setTransactional(envConfig.getTransactional()); store = new EntityStore(env, "test", config); }
boolean openStoreReadWrite() throws Exception { StoreConfig config = new StoreConfig(); config.setAllowCreate(true); final boolean retVal = openStore(config); if (retVal) { caseObj.newMetadataWritten = true; } return retVal; }
void openNewStore() throws Exception { StoreConfig config = new StoreConfig(); config.setAllowCreate(true); config.setTransactional(true); EntityModel model = new AnnotationModel(); config.setModel(model); caseObj.configure(model, config); newStore = new EntityStore(env, "new", config); }
private void open(Class clsToRegister) throws DatabaseException { StoreConfig config = new StoreConfig(); config.setAllowCreate(envConfig.getAllowCreate()); if (clsToRegister != null) { com.sleepycat.persist.model.EntityModel model = new com.sleepycat.persist.model.AnnotationModel(); model.registerClass(clsToRegister); config.setModel(model); } open(config); }
/** Create all primary and secondary indices. */ private void init() throws DatabaseException { /* Open a transactional entity store. */ System.out.println("-> Creating a BDB database"); StoreConfig storeConfig = new StoreConfig(); storeConfig.setAllowCreate(true); storeConfig.setTransactional(true); store = new EntityStore(env, "ExampleStore", storeConfig); eventByTime = store.getPrimaryIndex(Date.class, Event.class); eventByPrice = store.getSecondaryIndex(eventByTime, Integer.class, "price"); }
private void openGroup() throws IOException { EnvironmentConfig envConfig = new EnvironmentConfig(); envConfig.setTransactional(true); envConfig.setAllowCreate(true); ReplicationConfig repConfig = new ReplicationConfig(); repConfig.setConfigParam(RepParams.VLSN_LOG_CACHE_SIZE.getName(), "2"); repEnvInfo = RepTestUtils.setupEnvInfos(envRoot, nNodes, envConfig, repConfig); master = RepTestUtils.joinGroup(repEnvInfo); StoreConfig config = new StoreConfig(); config.setAllowCreate(true); config.setTransactional(true); store = new EntityStore(master, "test", config); primaryIndex = store.getPrimaryIndex(Integer.class, AppData.class); }
/** Opens the store. */ private void open() throws DatabaseException { StoreConfig config = new StoreConfig(); config.setAllowCreate(envConfig.getAllowCreate()); config.setTransactional(envConfig.getTransactional()); store = new EntityStore(env, "test", config); primary = store.getPrimaryIndex(Integer.class, MyEntity.class); oneToOne = store.getSecondaryIndex(primary, Integer.class, "oneToOne"); manyToOne = store.getSecondaryIndex(primary, Integer.class, "manyToOne"); oneToMany = store.getSecondaryIndex(primary, Integer.class, "oneToMany"); manyToMany = store.getSecondaryIndex(primary, Integer.class, "manyToMany"); assertNotNull(primary); assertNotNull(oneToOne); assertNotNull(manyToOne); assertNotNull(oneToMany); assertNotNull(manyToMany); rawStore = new RawStore(env, "test", config); String clsName = MyEntity.class.getName(); entityType = rawStore.getModel().getRawType(clsName); assertNotNull(entityType); primaryRaw = rawStore.getPrimaryIndex(clsName); oneToOneRaw = rawStore.getSecondaryIndex(clsName, "oneToOne"); manyToOneRaw = rawStore.getSecondaryIndex(clsName, "manyToOne"); oneToManyRaw = rawStore.getSecondaryIndex(clsName, "oneToMany"); manyToManyRaw = rawStore.getSecondaryIndex(clsName, "manyToMany"); assertNotNull(primaryRaw); assertNotNull(oneToOneRaw); assertNotNull(manyToOneRaw); assertNotNull(oneToManyRaw); assertNotNull(manyToManyRaw); }
/** * Load the index data from the input file and transfer it to the persistent hash table * * @param dbDir */ public void setup(File dbDir) { try { // Setup needed classes for interacting with Berkeley DNB Java Edition EnvironmentConfig envConfig = new EnvironmentConfig(); StoreConfig storeConfig = new StoreConfig(); envConfig.setAllowCreate(true); // Try to keep a high amount of data in the cache. envConfig.setCachePercent(80); storeConfig.setAllowCreate(true); this.myDbEnvironment = new Environment(dbDir, envConfig); this.dictStore = new EntityStore(myDbEnvironment, "EntityStore", storeConfig); this.pidx = dictStore.getPrimaryIndex(String.class, KeyValueEntry.class); if (this.pidx.count() == 0) { // prep the index try { BufferedReader reader = new BufferedReader(new FileReader(this.indexFile)); String line = null; while ((line = reader.readLine()) != null) { // de-serialize object from input file KeyValueEntry kvp = KeyValueEntry.fromString(line); // store in persistent hash table this.pidx.put(kvp); } reader.close(); } catch (IOException ioe) { ioe.printStackTrace(); } } } catch (DatabaseException dbe) { this.myDbEnvironment = null; this.dictStore = null; this.pidx = null; } }
private void doSecondaryBulkLoad(boolean closeAndOpenNormally) throws DatabaseException { PrimaryIndex<Integer, RelatedX> priX; PrimaryIndex<Integer, RelatedY> priY; SecondaryIndex<Integer, Integer, RelatedX> secX; /* Open priX with SecondaryBulkLoad=true. */ StoreConfig config = new StoreConfig(); config.setAllowCreate(true); config.setSecondaryBulkLoad(true); open(config); /* Getting priX should not create the secondary index. */ priX = store.getPrimaryIndex(Integer.class, RelatedX.class); PersistTestUtils.assertDbExists(false, env, STORE_NAME, RelatedX.class.getName(), "key2"); /* We can put records that violate the secondary key constraint. */ priX.put(new RelatedX()); if (closeAndOpenNormally) { /* Open normally and attempt to populate the secondary. */ close(); open(); if (isTransactional && DbCompat.POPULATE_ENFORCES_CONSTRAINTS) { /* Constraint enforcement requires transactions. */ try { /* Before adding the foreign key, constraint is violated. */ priX = store.getPrimaryIndex(Integer.class, RelatedX.class); fail(); } catch (DatabaseException e) { assertTrue(e.toString(), e.toString().contains("foreign key not allowed")); } } /* Open priX with SecondaryBulkLoad=true. */ close(); open(config); /* Add the foreign key to avoid the constraint error. */ priY = store.getPrimaryIndex(Integer.class, RelatedY.class); priY.put(new RelatedY()); /* Open normally and the secondary will be populated. */ close(); open(); priX = store.getPrimaryIndex(Integer.class, RelatedX.class); PersistTestUtils.assertDbExists(true, env, STORE_NAME, RelatedX.class.getName(), "key2"); secX = store.getSecondaryIndex(priX, Integer.class, "key2"); } else { /* Get secondary index explicitly and it will be populated. */ if (isTransactional && DbCompat.POPULATE_ENFORCES_CONSTRAINTS) { /* Constraint enforcement requires transactions. */ try { /* Before adding the foreign key, constraint is violated. */ secX = store.getSecondaryIndex(priX, Integer.class, "key2"); fail(); } catch (DatabaseException e) { assertTrue(e.toString(), e.toString().contains("foreign key not allowed")); } } /* Add the foreign key. */ priY = store.getPrimaryIndex(Integer.class, RelatedY.class); priY.put(new RelatedY()); secX = store.getSecondaryIndex(priX, Integer.class, "key2"); PersistTestUtils.assertDbExists(true, env, STORE_NAME, RelatedX.class.getName(), "key2"); } RelatedX x = secX.get(88); assertNotNull(x); close(); }
public void testSubclassIndex() throws DatabaseException { EnvironmentConfig envConfig = new EnvironmentConfig(); envConfig.setAllowCreate(true); env = new Environment(envHome, envConfig); StoreConfig storeConfig = new StoreConfig(); storeConfig.setAllowCreate(true); EntityStore store = new EntityStore(env, "foo", storeConfig); PrimaryIndex<String, Employee> employeesById = store.getPrimaryIndex(String.class, Employee.class); employeesById.put(new Employee("1")); employeesById.put(new Manager("2", "a")); employeesById.put(new Manager("3", "a")); employeesById.put(new Manager("4", "b")); Employee e; Manager m; e = employeesById.get("1"); assertNotNull(e); assertTrue(!(e instanceof Manager)); /* Ensure DB exists BEFORE calling getSubclassIndex. [#15247] */ PersistTestUtils.assertDbExists(true, env, "foo", Employee.class.getName(), "dept"); /* Normal use: Subclass index for a key in the subclass. */ SecondaryIndex<String, String, Manager> managersByDept = store.getSubclassIndex(employeesById, Manager.class, String.class, "dept"); m = managersByDept.get("a"); assertNotNull(m); assertEquals("2", m.id); m = managersByDept.get("b"); assertNotNull(m); assertEquals("4", m.id); EntityCursor<Manager> managers = managersByDept.entities(); try { m = managers.next(); assertNotNull(m); assertEquals("2", m.id); m = managers.next(); assertNotNull(m); assertEquals("3", m.id); m = managers.next(); assertNotNull(m); assertEquals("4", m.id); m = managers.next(); assertNull(m); } finally { managers.close(); } /* Getting a subclass index for the entity class is also allowed. */ store.getSubclassIndex(employeesById, Employee.class, String.class, "other"); /* Getting a subclass index for a base class key is not allowed. */ try { store.getSubclassIndex(employeesById, Manager.class, String.class, "other"); fail(); } catch (IllegalArgumentException expected) { } store.close(); env.close(); env = null; }