public void close () { db.close(); }
DB storage = storageRegistry.get(storageType); if(isOpenStorage(storage)) { storage.commit(); Engine e = storage.getEngine(); while (EngineWrapper.class.isAssignableFrom(e.getClass())) { e = ((EngineWrapper) e).getWrappedEngine(); storage.close(); while (!e.isClosed()) { logger.trace("Waiting for the engine to close");
@Override public <K, V> Map<K, V> getMap(String name) { return db.<K, V>hashMap(name, JAVA, JAVA).createOrOpen(); }
private GTFSFeed (DB db) { this.db = db; agency = db.getTreeMap("agency"); feedInfo = db.getTreeMap("feed_info"); routes = db.getTreeMap("routes"); trips = db.getTreeMap("trips"); stop_times = db.getTreeMap("stop_times"); frequencies = db.getTreeSet("frequencies"); transfers = db.getTreeMap("transfers"); stops = db.getTreeMap("stops"); fares = db.getTreeMap("fares"); services = db.getTreeMap("services"); shape_points = db.getTreeMap("shape_points"); feedId = db.getAtomicString("feed_id").get(); checksum = db.getAtomicLong("checksum").get(); errors = db.getTreeSet("errors"); }
assert valueSerializer != null; this.converter = converter; if (db.exists(name)) { logger.debug("Reopening storage for '{0}' index in workspace '{1}'", name, workspaceName); this.options = db.getHashMap(name + "/options"); this.keysByValue = db.getTreeMap(name); this.valuesByKey = db.getTreeSet(name + "/inverse"); this.isNew = false; } else { logger.debug("Creating storage for '{0}' index in workspace '{1}'", name, workspaceName); this.isNew = true; this.options = db.createHashMap(name + "/options").makeOrGet(); this.keysByValue = db.createTreeMap(name).counterEnable().comparator(valueSerializer.getComparator()) .keySerializer(valueSerializer).makeOrGet(); valueRawSerializer, revComparator); this.valuesByKey = db.createTreeSet(name + "/inverse").comparator(revComparator).serializer(revSerializer).makeOrGet();
File file = new File(“dbFileName”); DB db = DBMaker.newFileDB(file).make(); //use map Map map = db.getHashMap(“mapName”); map.put(“aa”,”bb”); //commit and close database db.commit(); db.close();
.make(); comparison = comparisonDb.getTreeMap("results"); .make(); final BTreeMap<Fun.Tuple3<String, String, ResultEnvelope.Which>, Integer> output = outputDb.createTreeMap("results") .valueSerializer(Serializer.JAVA) .makeOrGet(); pset = comparisonDb.<String, PointSet>getTreeMap("pointset").get("pointset"); outputDb.createTreeMap("pointset") .<String, PointSet>make().put("pointset", pset); comparisonDb.close();
@Override public void commit() { db.commit(); }
@Override public void addUser(String username, String password, String givenName, String familyName, Collection<String> roles) { ClassLoader old = Thread.currentThread().getContextClassLoader(); try { Thread.currentThread().setContextClassLoader(getClass().getClassLoader()); synchronized (db) { Map<String, Object> m = db.createTreeMap(username).makeOrGet(); m.put("user", username); m.put("password", DigestUtils.sha256Hex(password)); m.put("givenName", givenName); m.put("familyName", familyName); m.put("roles", new ArrayList<>(roles)); db.commit(); } } finally { Thread.currentThread().setContextClassLoader(old); } }
public Map<String, Object> getMappingFor(String tableId, String keyId, String valueId) { String mapid = null; String key = tableId + "|" + keyId + "|" + valueId; if (cache.containsKey(key)) { return cache.get(key); } if (mappings.get(key) == null) { mapid = UUID.randomUUID().toString(); mappings.put(key, mapid); } else { mapid = mappings.get(key); } Map<String, Object> ret = db.getTreeMap(mapid); db.commit(); cache.put(key, ret); return ret; } }
public void indexInteractions() { DB db = DBMaker .newMemoryDirectDB() .compressionEnable() .transactionDisable() .make(); final Map<Fun.Tuple3<Long, String, Long>, Long> taxonInteractions = db .createTreeMap("ottIdMap") .make(); collectTaxonInteractions(taxonInteractions); createTaxonInteractions(taxonInteractions); db.close(); }
protected NavigableMap makeMap(KeyFunction keyfunc) { if (db == null) init(); String name = keyfunc.getClass().getName(); if (!db.exists(name)) return db.createTreeMap(name) .valueSerializer(new BlockSerializer()) .make(); else return db.getTreeMap(name); }
DB db = DBMaker.openFile(fileName).make(); Map<Integer,Integer> map = db.createHashMap("mapName"); map.put(5, 10); db.close()
protected NavigableMap<BindingSet, Integer> makeOrderedMap() { if (db == null) { // no disk-syncing - we use a simple in-memory TreeMap instead. return new TreeMap<BindingSet, Integer>(comparator); } else { return db.createTreeMap("iteration").comparator(comparator).makeOrGet(); } }
this.cacheName = StringUtils.format("cache-%s", UUID.randomUUID()); this.reverseCacheName = StringUtils.format("reverseCache-%s", UUID.randomUUID()); mapCache = DB.createHashMap(cacheName).make(); reverseCache = DB.createHashMap(reverseCacheName).make(); ImmutableSet.Builder<V> setOfValuesBuilder = ImmutableSet.builder(); for (Map.Entry<K, V> entry : entries) {
private void init() { DBMaker maker; if (file == null) maker = DBMaker.newMemoryDB(); else { if (overwrite) wipe(file); maker = DBMaker.newFileDB(new File(file)); maker = maker.cacheSize(cache_size); if (async) { maker = maker.asyncWriteEnable(); maker = maker.asyncWriteFlushDelay(10000); } if (mmap) maker = maker.mmapFileEnableIfSupported(); if (compression) maker = maker.compressionEnable(); if (snapshot) maker = maker.snapshotEnable(); if (notxn) maker = maker.transactionDisable(); } db = maker.make(); if (!db.exists("idmap")) idmap = db.createHashMap("idmap") .valueSerializer(new RecordSerializer()) .make(); else idmap = db.getHashMap("idmap"); }