Example #1
0
  public void merge() throws Exception {
    LOG.info("start merge");
    Database crawldbDatabase = env.openDatabase(null, "crawldb", BerkeleyDBUtils.defaultDBConfig);
    /*合并fetch库*/
    LOG.info("merge fetch database");
    Database fetchDatabase = env.openDatabase(null, "fetch", BerkeleyDBUtils.defaultDBConfig);
    Cursor fetchCursor = fetchDatabase.openCursor(null, null);
    DatabaseEntry key = new DatabaseEntry();
    DatabaseEntry value = new DatabaseEntry();
    while (fetchCursor.getNext(key, value, LockMode.DEFAULT) == OperationStatus.SUCCESS) {
      crawldbDatabase.put(null, key, value);
    }
    fetchCursor.close();
    fetchDatabase.close();
    /*合并link库*/
    LOG.info("merge link database");
    Database linkDatabase = env.openDatabase(null, "link", BerkeleyDBUtils.defaultDBConfig);
    Cursor linkCursor = linkDatabase.openCursor(null, null);
    while (linkCursor.getNext(key, value, LockMode.DEFAULT) == OperationStatus.SUCCESS) {
      if (!(crawldbDatabase.get(null, key, value, LockMode.DEFAULT) == OperationStatus.SUCCESS)) {
        crawldbDatabase.put(null, key, value);
      }
    }
    linkCursor.close();
    linkDatabase.close();
    LOG.info("end merge");
    crawldbDatabase.sync();
    crawldbDatabase.close();

    env.removeDatabase(null, "fetch");
    LOG.debug("remove fetch database");
    env.removeDatabase(null, "link");
    LOG.debug("remove link database");
  }
  public BDB_GIDLookupImpl(String aim) {

    EnvironmentConfig environmentConfig = new EnvironmentConfig();

    // will be created if not existing -> will crash if folder not found
    environmentConfig.setAllowCreate(true);

    // no transaction yet -> might be needed later
    // not sure if needed to be set in environment and database
    environmentConfig.setTransactional(false);

    File file = new File(aim);

    if (!file.exists()) {
      file.mkdirs();
    }

    environment = new Environment(file, environmentConfig);
    DatabaseConfig databaseConfig = new DatabaseConfig();

    // will be created if not existing -> will crash if folder not found
    databaseConfig.setAllowCreate(true);

    // no transaction yet -> might be needed later
    // not sure if needed to be set in environment and database
    databaseConfig.setTransactional(false);

    // create 2 "tables" one for relations-gid one for node-gid
    RelationBDB = environment.openDatabase(null, "Relation", databaseConfig);
    NodeBDB = environment.openDatabase(null, "Node", databaseConfig);
  }
Example #3
0
  public AbstractFrontier(String homeDirectory) throws DatabaseException, FileNotFoundException {
    // 打开env
    File file = new File(homeDirectory);
    if (!file.exists()) {
      file.mkdirs();
    }
    System.out.println("Opening environment in: " + homeDirectory);
    EnvironmentConfig envConfig = new EnvironmentConfig();
    envConfig.setTransactional(true);
    envConfig.setAllowCreate(true);

    env = new Environment(new File(homeDirectory), envConfig);
    // 设置DatabaseConfig
    DatabaseConfig dbConfig = new DatabaseConfig();
    dbConfig.setTransactional(true);
    dbConfig.setAllowCreate(true);
    dbConfig.setSortedDuplicates(false);
    // 打开
    catalogdatabase = env.openDatabase(null, CLASS_CATALOG, dbConfig);
    javaCatalog = new StoredClassCatalog(catalogdatabase);
    // 设置DatabaseConfig
    DatabaseConfig dbConfig0 = new DatabaseConfig();
    dbConfig0.setTransactional(true);
    dbConfig0.setAllowCreate(true);
    // 打开
    database = env.openDatabase(null, "URL", dbConfig);
  }
  /*
   * Check that the notReplicate attribute is properly immutable and
   * persistent.
   */
  private void validate(DatabaseConfig config, boolean replicated) throws DatabaseException {

    /* Create the database -- is its config what we expect? */
    db = env.openDatabase(null, TEST_DB, config);
    DatabaseConfig inUseConfig = db.getConfig();
    assertEquals(replicated, DbInternal.getReplicated(inUseConfig));

    /* Close, re-open. */
    db.close();
    db = null;
    db = env.openDatabase(null, TEST_DB, inUseConfig);
    assertEquals(replicated, DbInternal.getReplicated(db.getConfig()));

    /*
     * Close, re-open w/inappropriate value for the replicated bit. This is
     * only checked for replicated environments.
     */
    db.close();
    db = null;
    if (DbInternal.getEnvironmentImpl(env).isReplicated()) {
      DbInternal.setReplicated(inUseConfig, !replicated);
      try {
        db = env.openDatabase(null, TEST_DB, inUseConfig);
        fail("Should have caught config mismatch");
      } catch (IllegalArgumentException expected) {
      }
    }
  }
  public BerkeleyStorage(File file, boolean readonly, boolean async) {
    if (file == null) {
      int pid = 0;
      try {
        pid = Integer.parseInt((new File("/proc/self")).getCanonicalFile().getName());
      } catch (NumberFormatException | IOException e) {
      }
      String path = "/tmp";
      String db_path = System.getenv("DB");
      if (db_path != null) {
        path = db_path;
      }
      file = new File(path + "/ringpaxos-db/" + pid);
      file.mkdirs();
    }
    EnvironmentConfig envConfig = new EnvironmentConfig();
    DatabaseConfig dbConfig = new DatabaseConfig();
    envConfig.setReadOnly(readonly);
    dbConfig.setReadOnly(readonly);
    envConfig.setAllowCreate(!readonly);
    dbConfig.setAllowCreate(!readonly);

    // performance settings
    envConfig.setTransactional(true);
    envConfig.setCacheMode(CacheMode.DEFAULT);
    // envConfig.setCacheSize(1000000*800); // 800M
    if (async) {
      dbConfig.setTransactional(false);
      envConfig.setDurability(Durability.COMMIT_NO_SYNC);
      dbConfig.setDeferredWrite(true);
    } else {
      dbConfig.setTransactional(true);
      envConfig.setDurability(Durability.COMMIT_SYNC);
      dbConfig.setDeferredWrite(false);
    }

    env = new Environment(file, envConfig);
    db = env.openDatabase(null, "paxosDB", dbConfig);
    classCatalogDb = env.openDatabase(null, "ClassCatalogDB", dbConfig);
    classCatalog = new StoredClassCatalog(classCatalogDb);
    keyBinding = TupleBinding.getPrimitiveBinding(Long.class);
    dataBinding = new SerialBinding<Decision>(classCatalog, Decision.class);
    ballotBinding = TupleBinding.getPrimitiveBinding(Integer.class);

    logger.info("BerkeleyStorage cache size: " + env.getMutableConfig().getCacheSize());
    logger.info(
        "BerkeleyStorage durability: " + env.getMutableConfig().getDurability().getLocalSync());
    logger.info("BerkeleyStorage deferred write: " + db.getConfig().getDeferredWrite());
  }
Example #6
0
  public BDBCreator(String tableName, ArrayList<Integer> keyPositions, int secondaryIndex) {
    /* Creates and loads a BDB table with a secondary index on the column defined by*/
    this.tableName = tableName.toLowerCase();
    this.keyPositions = keyPositions;
    this.secIndexPos = secondaryIndex;
    this.tMap = Main.indexTypeMaps.get(this.tableName);
    setEnvironment();

    dbConfig = new DatabaseConfig();
    dbConfig.setAllowCreate(true);
    myDB = myDbEnvironment.openDatabase(null, this.tableName, dbConfig);
    SecondaryConfig secConfig = new SecondaryConfig();
    secConfig.setAllowCreate(true);
    secConfig.setSortedDuplicates(true);

    createSecDB(secConfig);
    setConfig(dbConfig, secConfig);

    loadData();

    if (secDB != null) {
      secDB.close();
    }
    if (myDB != null) {
      myDB.close();
    }

    closeEnvironment();
  }
    /* Insert 100 records begins with the beginKey. */
    private void doWork(Environment master, String dbName, int beginKey) throws Exception {

      DatabaseConfig dbConfig = new DatabaseConfig();
      dbConfig.setAllowCreate(true);
      dbConfig.setTransactional(true);

      /* Insert/Update the records of the database. */
      Database db = master.openDatabase(null, dbName, dbConfig);
      DatabaseEntry key = new DatabaseEntry();
      DatabaseEntry data = new DatabaseEntry();

      for (int i = 0; i < 100; i++) {
        IntegerBinding.intToEntry(beginKey + i, key);
        StringBinding.stringToEntry("herococo", data);
        db.put(null, key, data);
      }
      db.close();

      /*
       * Do a sync at the end of the stage to make sure master and
       * replica have the same data set.
       */
      VLSN commitVLSN = RepTestUtils.syncGroupToLastCommit(repEnvInfo, repEnvInfo.length);
      RepTestUtils.checkNodeEquality(commitVLSN, false, repEnvInfo);
    }
 public ByteStoreBDB(File dir, String dbname, boolean ro) {
   this.dir = Files.initDirectory(dir);
   this.readonly = ro;
   settings = new SettingsJE();
   EnvironmentConfig bdb_eco = new EnvironmentConfig();
   bdb_eco.setReadOnly(ro);
   bdb_eco.setAllowCreate(!ro);
   bdb_eco.setTransactional(false);
   //          bdb_eco.setDurability(Durability.COMMIT_NO_SYNC);
   if (ro) {
     bdb_eco.setConfigParam(
         EnvironmentConfig.ENV_RUN_CLEANER, "false"); // Disable log cleaner thread
     bdb_eco.setCacheMode(CacheMode.EVICT_LN);
   }
   JEUtil.mergeSystemProperties(bdb_eco);
   SettingsJE.updateEnvironmentConfig(settings, bdb_eco);
   bdb_env = new Environment(dir, bdb_eco);
   bdb_cfg = new DatabaseConfig();
   bdb_cfg.setReadOnly(ro);
   bdb_cfg.setAllowCreate(true);
   bdb_cfg.setDeferredWrite(true);
   SettingsJE.updateDatabaseConfig(settings, bdb_cfg);
   bdb = bdb_env.openDatabase(null, dbname, bdb_cfg);
   if (log.isDebugEnabled()) {
     log.debug(SettingsJE.dumpDebug(bdb));
   }
 }
Example #9
0
  private void verifyDb(Hashtable dataMap, int dumpIndex) throws DatabaseException {

    DatabaseConfig config = new DatabaseConfig();
    config.setReadOnly(true);
    DbInternal.setUseExistingConfig(config, true);
    Database myDb = env.openDatabase(null, dbName + dumpIndex, config);
    Cursor cursor = myDb.openCursor(null, null);
    StringDbt foundKey = new StringDbt();
    StringDbt foundData = new StringDbt();
    OperationStatus status = cursor.getFirst(foundKey, foundData, LockMode.DEFAULT);
    while (status == OperationStatus.SUCCESS) {
      String foundKeyString = foundKey.getString();
      String foundDataString = foundData.getString();
      if (dataMap.get(foundKeyString) != null) {
        assertTrue(((String) dataMap.get(foundKeyString)).equals(foundDataString));
        dataMap.remove(foundKeyString);
      } else {
        fail("didn't find key in either map (" + foundKeyString + ")");
      }
      status = cursor.getNext(foundKey, foundData, LockMode.DEFAULT);
    }
    assertTrue(dataMap.size() == 0);
    cursor.close();
    myDb.close();
  }
Example #10
0
  public void run(File envHomeDirectory) throws DatabaseException, IOException {

    /* Create the environment object. */
    EnvironmentConfig envConfig = new EnvironmentConfig();
    envConfig.setAllowCreate(true);
    Environment env = new Environment(envHomeDirectory, envConfig);

    /* Create the database object. */
    DatabaseConfig dbConfig = new DatabaseConfig();
    dbConfig.setAllowCreate(true);
    Database db = env.openDatabase(null, DB_NAME, dbConfig);

    /* Create the sequence oject. */
    SequenceConfig config = new SequenceConfig();
    config.setAllowCreate(true);
    DatabaseEntry key = new DatabaseEntry(KEY_NAME.getBytes("UTF-8"));
    Sequence seq = db.openSequence(null, key, config);

    /* Allocate a few sequence numbers. */
    for (int i = 0; i < 10; i++) {
      long seqnum = seq.get(null, 1);
      System.out.println("Got sequence number: " + seqnum);
    }

    /* Close all. */
    seq.close();
    db.close();
    env.close();
  }
Example #11
0
  public Database getDb(String dbName, boolean readOnly) throws DatabaseException {

    myDbConfig = new DatabaseConfig();
    myDbConfig.setReadOnly(readOnly);
    myDbConfig.setAllowCreate(!readOnly);

    return myEnv.openDatabase(null, dbName, myDbConfig);
  }
 /** @see org.geogit.storage.ObjectDatabase#create() */
 @Override
 public void create() {
   txn = CurrentTransaction.getInstance(env);
   DatabaseConfig dbConfig = new DatabaseConfig();
   dbConfig.setAllowCreate(true);
   dbConfig.setTransactional(env.getConfig().getTransactional());
   this.objectDb = env.openDatabase(null, "BlobStore", dbConfig);
 }
Example #13
0
 public void lock() throws Exception {
   lockDatabase = env.openDatabase(null, "lock", BerkeleyDBUtils.defaultDBConfig);
   DatabaseEntry key = new DatabaseEntry("lock".getBytes("utf-8"));
   DatabaseEntry value = new DatabaseEntry("locked".getBytes("utf-8"));
   lockDatabase.put(null, key, value);
   lockDatabase.sync();
   lockDatabase.close();
 }
 protected Database openDatabase(final Environment environment, final String dbName)
     throws DatabaseException {
   DatabaseConfig dbConfig = new DatabaseConfig();
   dbConfig.setTransactional(false);
   dbConfig.setAllowCreate(true);
   dbConfig.setDeferredWrite(true);
   return environment.openDatabase(null, dbName, dbConfig);
 }
  private static void openEnv() throws DatabaseException {
    System.out.println("opening env");

    // Set up the environment.
    EnvironmentConfig myEnvConfig = new EnvironmentConfig();
    myEnvConfig.setAllowCreate(true);
    myEnvConfig.setTransactional(true);
    // Environment handles are free-threaded in JE,
    // so we do not have to do anything to cause the
    // environment handle to be free-threaded.

    // Set up the database
    DatabaseConfig myDbConfig = new DatabaseConfig();
    myDbConfig.setAllowCreate(true);
    myDbConfig.setTransactional(true);
    myDbConfig.setSortedDuplicates(true);
    // no DatabaseConfig.setThreaded() method available.
    // db handles in java are free-threaded so long as the
    // env is also free-threaded.

    // Open the environment
    myEnv =
        new Environment(
            new File(myEnvPath), // Env home
            myEnvConfig);

    // Open the database. Do not provide a txn handle. This open
    // is autocommitted because DatabaseConfig.setTransactional()
    // is true.
    myDb =
        myEnv.openDatabase(
            null, // txn handle
            dbName, // Database file name
            myDbConfig);

    // Used by the bind API for serializing objects
    // Class database must not support duplicates
    myDbConfig.setSortedDuplicates(false);
    myClassDb =
        myEnv.openDatabase(
            null, // txn handle
            cdbName, // Database file name
            myDbConfig);
  }
Example #16
0
 public WorkQueues(Environment env, String dbName, boolean resumable) throws DatabaseException {
   this.env = env;
   this.resumable = resumable;
   DatabaseConfig dbConfig = new DatabaseConfig();
   dbConfig.setAllowCreate(true);
   dbConfig.setTransactional(resumable);
   dbConfig.setDeferredWrite(!resumable);
   urlsDB = env.openDatabase(null, dbName, dbConfig);
   webURLBinding = new WebURLTupleBinding();
 }
Example #17
0
  public Database setDatabase(String dbName, boolean readOnly) throws DatabaseException {

    myDbConfig = new DatabaseConfig();
    myDbConfig.setReadOnly(readOnly);
    myDbConfig.setAllowCreate(!readOnly);

    Database db = myEnv.openDatabase(null, dbName, myDbConfig);
    myDbHashHandle.put(dbName, db);
    return db;
  }
  /**
   * Make a thread allocate a vlsn, but then fail before it's tracked by the vlsn index. This
   * happened in [#20919] when 1.rep environment close was called 2.the repNode was nulled out 3.a
   * concurrent writing thread got a NPE within its call to LogManager.log because the repNode was
   * null. This thread exited after it had bumped the vlsn, but before it had entered the vlsn in
   * the vlsnIndex 4.rep environment close tried to do a checkpoint, but the checkpoint hung. This
   * fix works by having (3) invalidate the environment, and by having (4) check for an invalidated
   * environment.
   */
  @Test
  public void testLoggingFailure() throws DatabaseException, IOException {

    /* Make a single replicated environment. */
    RepEnvInfo[] repEnvInfo = RepTestUtils.setupEnvInfos(envRoot, 1);
    RepTestUtils.joinGroup(repEnvInfo);

    /*
     * Disable cleaning and CBVLSN updating, to control vlsn creation
     * explicitly.
     */
    Environment env = repEnvInfo[0].getEnv();
    EnvironmentMutableConfig config = env.getMutableConfig();
    config.setConfigParam("je.env.runCleaner", "false");
    env.setMutableConfig(config);
    LocalCBVLSNUpdater.setSuppressGroupDBUpdates(false);

    DatabaseConfig dbConfig = new DatabaseConfig();
    dbConfig.setTransactional(true);
    dbConfig.setAllowCreate(true);
    Database db = env.openDatabase(null, "foo", dbConfig);
    DatabaseEntry value = new DatabaseEntry(new byte[4]);

    EnvironmentImpl envImpl = DbInternal.getEnvironmentImpl(env);
    LogManager logManager = DbInternal.getEnvironmentImpl(env).getLogManager();

    /*
     * Inject an exception into the next call to log() that is made
     * for a replicated log entry.
     */
    logManager.setDelayVLSNRegisterHook(new ForceException());

    VLSNIndex vlsnIndex = ((RepImpl) envImpl).getVLSNIndex();

    try {
      db.put(null, value, value);
      fail("Should throw exception");
    } catch (Exception expected) {
      assertTrue(
          "latest="
              + vlsnIndex.getLatestAllocatedVal()
              + " last mapped="
              + vlsnIndex.getRange().getLast().getSequence(),
          vlsnIndex.getLatestAllocatedVal() > vlsnIndex.getRange().getLast().getSequence());
    }

    try {
      VLSNIndex.AWAIT_CONSISTENCY_MS = 1000;
      envImpl.awaitVLSNConsistency();
      fail("Should throw and break out");
    } catch (DatabaseException expected) {
    }

    /* Before the fix, this test hung. */
  }
Example #19
0
  /**
   * constructor
   *
   * @param myEnv
   * @param dbName
   */
  public MyDatabase(Environment myEnv, String dbName) {
    this.myEnv = myEnv;
    this.dbName = dbName;

    DatabaseConfig dbConfig = new DatabaseConfig();

    dbConfig.setAllowCreate(true);
    dbConfig.setTransactional(true);
    dbConfig.setAllowCreate(true);
    myDatabase = myEnv.openDatabase(null, dbName, dbConfig);
  }
Example #20
0
 public BtreeFile createBtreeFile(String csName) // , boolean bCanSortMultiThreads)
     {
   // Now open, or create and open, the database
   try {
     Database bdb = m_env.openDatabase(null, csName, m_DbConfig);
     BtreeFile btreeFile = new BtreeFile(bdb); // , bCanSortMultiThreads);
     return btreeFile;
   } catch (DatabaseException e) {
     e.printStackTrace();
     return null;
   }
 }
 public StorageEngine<ByteArray, byte[], byte[]> getStore(String storeName) {
   synchronized (lock) {
     try {
       Environment environment = getEnvironment(storeName);
       Database db = environment.openDatabase(null, storeName, databaseConfig);
       BdbRuntimeConfig runtimeConfig = new BdbRuntimeConfig(voldemortConfig);
       BdbStorageEngine engine = new BdbStorageEngine(storeName, environment, db, runtimeConfig);
       return engine;
     } catch (DatabaseException d) {
       throw new StorageInitializationException(d);
     }
   }
 }
    /* Do the real reading work. */
    private void doRead(Environment env, DatabaseConfig dbConfig, ArrayList<TestObject> list)
        throws Exception {

      Database db = env.openDatabase(null, dbName, dbConfig);
      Cursor cursor = db.openCursor(null, null);
      DatabaseEntry key = new DatabaseEntry();
      DatabaseEntry data = new DatabaseEntry();
      while (OperationStatus.SUCCESS == cursor.getNext(key, data, null)) {
        list.add(new TestObject(IntegerBinding.entryToInt(key), StringBinding.entryToString(data)));
      }
      cursor.close();
      db.close();
    }
Example #23
0
  public static void main(String[] args) {
    Environment env = null;
    Database db = null;
    EnvironmentConfig envconfig = new EnvironmentConfig();
    envconfig.setAllowCreate(true);
    try {
      env = new Environment(new File("D://bdb"), envconfig);
      DatabaseConfig dbconfig = new DatabaseConfig();
      dbconfig.setAllowCreate(true);
      db = env.openDatabase(null, "dbac.db", dbconfig);
      String key = "mykey";
      DatabaseEntry thekey = new DatabaseEntry();
      thekey.setData(key.getBytes("utf-8"));

      Long value = new Long(123456);
      DatabaseEntry thevalue = new DatabaseEntry();
      EntryBinding myBinging = TupleBinding.getPrimitiveBinding(Long.class);
      myBinging.objectToEntry(value, thevalue);
      // LongBinding myLongBinging=(LongBinding)TupleBinding.getPrimitiveBinding(Long.class);
      // myLongBinging.objectToEntry(value, thevalue);
      db.put(null, thekey, thevalue);
      DatabaseEntry valueEntry = new DatabaseEntry();
      OperationStatus status = db.get(null, thekey, valueEntry, LockMode.DEFAULT);
      if (status == OperationStatus.SUCCESS) {
        // Long number=myLongBinging.entryToObject(valueEntry);
        Long number = (Long) myBinging.entryToObject(valueEntry);
        System.out.println(env.getDatabaseNames());
        System.out.println(number);
      }
    } catch (EnvironmentLockedException e) {
      e.printStackTrace();
    } catch (Exception e) {
      e.printStackTrace();
    } finally {
      if (db != null) {
        try {
          db.close();
        } catch (DatabaseException e) {
          e.printStackTrace();
        }
      }
      if (env != null) {
        try {
          env.cleanLog();
          env.close();
        } catch (DatabaseException e) {
          e.printStackTrace();
        }
      }
    }
  }
Example #24
0
  public static <EnvironmenConfig> void envconfig() {
    EnvironmentConfig envConfig = new EnvironmentConfig();
    envConfig.setTransactional(false);
    envConfig.setAllowCreate(true);
    File envDir = new File("d://");

    try {
      // 新建环境变量
      Environment exampleEnv = new Environment(envDir, envConfig);
      String databaseName = "ToDoTaskList.db";
      DatabaseConfig dbConfig = new DatabaseConfig();
      dbConfig.setAllowCreate(true);
      dbConfig.setTransactional(false);
      // 打开用来存储类信息的数据库
      // 用来存储类信息的数据库数据库,不要求能共存储重复的关键字
      dbConfig.setSortedDuplicates(false);

      Database myClassDb = exampleEnv.openDatabase(null, databaseName, dbConfig);
      // 初始化catalog类
      StoredClassCatalog catalog = new StoredClassCatalog(myClassDb);
      TupleBinding<String> keyBinding = TupleBinding.getPrimitiveBinding(String.class);
      // 把value作为对象的序列化方式存储
      SerialBinding<String> valueBinding = new SerialBinding<String>(catalog, String.class);
      Database store = exampleEnv.openDatabase(null, databaseName, dbConfig);
      // 建立数据存储映射
      StoredSortedMap<String, String> map =
          new StoredSortedMap<String, String>(store, keyBinding, valueBinding, true);
      // 释放环境变量
      // exampleEnv.syncReplication();
      store.close();
      myClassDb.close();
      exampleEnv.close();
      exampleEnv = null;
    } catch (Exception e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
  }
  private void open(final boolean runCleaner) {
    final EnvironmentConfig envConfig = TestUtils.initEnvConfig();
    envConfig.setAllowCreate(true);
    envConfig.setConfigParam(EnvironmentConfig.LOG_FILE_MAX, Integer.toString(FILE_SIZE));
    envConfig.setConfigParam(EnvironmentConfig.CLEANER_MIN_UTILIZATION, "50");
    envConfig.setConfigParam(EnvironmentConfig.CLEANER_MIN_FILE_UTILIZATION, "0");
    envConfig.setConfigParam(EnvironmentConfig.ENV_RUN_CLEANER, runCleaner ? "true" : "false");
    envConfig.setConfigParam(EnvironmentConfig.ENV_RUN_CHECKPOINTER, "false");
    env = new Environment(envHome, envConfig);

    final DatabaseConfig dbConfig = new DatabaseConfig();
    dbConfig.setAllowCreate(true);
    db = env.openDatabase(null, DB_NAME, dbConfig);
  }
Example #26
0
 public boolean isLocked() throws Exception {
   boolean isLocked = false;
   lockDatabase = env.openDatabase(null, "lock", BerkeleyDBUtils.defaultDBConfig);
   DatabaseEntry key = new DatabaseEntry("lock".getBytes("utf-8"));
   DatabaseEntry value = new DatabaseEntry();
   if (lockDatabase.get(null, key, value, LockMode.DEFAULT) == OperationStatus.SUCCESS) {
     String lockInfo = new String(value.getData(), "utf-8");
     if (lockInfo.equals("locked")) {
       isLocked = true;
     }
   }
   lockDatabase.close();
   return isLocked;
 }
  public AbstractBerkeleyDB(String homeDirectory, String dbname) {
    // 打开env
    EnvironmentConfig envConfig = new EnvironmentConfig();
    envConfig.setTransactional(true);
    envConfig.setAllowCreate(true);
    File bdbHomeFile = new File(homeDirectory);
    if (!bdbHomeFile.exists()) bdbHomeFile.mkdirs();
    env = new Environment(bdbHomeFile, envConfig);

    if (database != null) return;
    // 设置DatabaseConfig
    DatabaseConfig dbConfig = new DatabaseConfig();
    dbConfig.setTransactional(true);
    dbConfig.setAllowCreate(true);
    // 打开
    catalogdatabase = env.openDatabase(null, CLASS_CATALOG, dbConfig);
    javaCatalog = new StoredClassCatalog(catalogdatabase);
    // 设置DatabaseConfig
    DatabaseConfig dbConfig0 = new DatabaseConfig();
    dbConfig0.setTransactional(true);
    dbConfig0.setAllowCreate(true);
    // 打开
    database = env.openDatabase(null, dbname, dbConfig);
  }
Example #28
0
  public BDBCreator(String tableName, ArrayList<Integer> keyPositions) {
    /* Creates and loads a BDB table without a secondary index*/
    this.tableName = tableName.toLowerCase();
    this.keyPositions = keyPositions;
    this.tMap = Main.indexTypeMaps.get(this.tableName);
    setEnvironment();

    dbConfig = new DatabaseConfig();
    dbConfig.setAllowCreate(true);
    myDB = myDbEnvironment.openDatabase(null, this.tableName, dbConfig);

    loadData();

    if (myDB != null) {
      myDB.close();
    }
    closeEnvironment();
  }
Example #29
0
 private void examine(File file) throws DatabaseInitException {
   openEnvironment(file);
   for (String tableName : environment.getDatabaseNames()) {
     Database table = environment.openDatabase(null, tableName, null);
     Cursor cursor = table.openCursor(null, cursorConfig);
     try {
       int count = 0;
       while (cursor.getNext(new DatabaseEntry(), new DatabaseEntry(), LockMode.DEFAULT)
           == OperationStatus.SUCCESS) {
         count++;
       }
       if (count != 0) {
         System.out.println(tableName + ": " + count);
       }
     } finally {
       cursor.close();
     }
   }
 }
Example #30
0
  /** Set up the environment and db. */
  private void initDbs(int nDumps, Hashtable[] dataMaps) throws DatabaseException {

    EnvironmentConfig envConfig = TestUtils.initEnvConfig();
    envConfig.setConfigParam(EnvironmentParams.NODE_MAX.getName(), "6");
    envConfig.setAllowCreate(true);
    env = new Environment(envHome, envConfig);

    /* Make a db and open it. */
    for (int i = 0; i < nDumps; i += 1) {
      DatabaseConfig dbConfig = new DatabaseConfig();
      dbConfig.setAllowCreate(true);
      dbConfig.setSortedDuplicates(true);
      Database myDb = env.openDatabase(null, dbName + i, dbConfig);
      Cursor cursor = myDb.openCursor(null, null);
      doLargePut(dataMaps[i], cursor, N_KEYS);
      cursor.close();
      myDb.close();
    }
  }