/* Initialize the database. */ void BulkExample::initDb(int dups, int sflag, int pagesize) { DbTxn *txnp; int ret; txnp = NULL; ret = 0; dbp = new Db(dbenv, 0); dbp->set_error_stream(&cerr); dbp->set_errpfx(progname); try{ if ((ret = dbp->set_bt_compare(compare_int)) != 0) throwException(dbenv, NULL, ret, "DB->set_bt_compare"); if ((ret = dbp->set_pagesize(pagesize)) != 0) throwException(dbenv, NULL, ret, "DB->set_pagesize"); if (dups && (ret = dbp->set_flags(DB_DUP)) != 0) throwException(dbenv, NULL, ret, "DB->set_flags"); if ((ret = dbenv->txn_begin(NULL, &txnp, 0)) != 0) throwException(dbenv, NULL, ret, "DB_ENV->txn_begin"); if ((ret = dbp->open(txnp, DATABASE, "primary", DB_BTREE, DB_CREATE, 0664)) != 0) throwException(dbenv, txnp, ret, "DB->open"); if (sflag) { sdbp = new Db(dbenv, 0); if ((ret = sdbp->set_flags(DB_DUPSORT)) != 0) throwException(dbenv, txnp, ret, "DB->set_flags"); if ((ret = sdbp->open(txnp, DATABASE, "secondary", DB_BTREE, DB_CREATE, 0664)) != 0) throwException(dbenv, txnp, ret, "DB->open"); if ((ret = dbp->associate( txnp, sdbp, get_first_str, 0)) != 0) throwException(dbenv, txnp, ret, "DB->associate"); } ret = txnp->commit(0); txnp = NULL; if (ret != 0) throwException(dbenv, NULL, ret, "DB_TXN->commit"); } catch(DbException &dbe) { cerr << "initDb " << dbe.what() << endl; if (txnp != NULL) (void)txnp->abort(); throw dbe; } }
Table Database::getTable(const std::string &tableName) throw (DbException) { uint32_t dbFlags = DB_CREATE | DB_AUTO_COMMIT; Db *db = new Db(&m_env, 0); db->open(NULL, tableName.c_str(), NULL, DB_BTREE, dbFlags, 0); return Table(db); }
// Open a Berkeley DB database int openDb(Db **dbpp, const char *progname, const char *fileName, DbEnv *envp, u_int32_t extraFlags) { int ret; u_int32_t openFlags; try { Db *dbp = new Db(envp, 0); // Point to the new'd Db *dbpp = dbp; if (extraFlags != 0) ret = dbp->set_flags(extraFlags); // Now open the database */ openFlags = DB_CREATE | // Allow database creation DB_THREAD | DB_AUTO_COMMIT; // Allow autocommit dbp->open(NULL, // Txn pointer fileName, // File name NULL, // Logical db name DB_BTREE, // Database type (using btree) openFlags, // Open flags 0); // File mode. Using defaults } catch (DbException &e) { std::cerr << progname << ": openDb: db open failed:" << std::endl; std::cerr << e.what() << std::endl; return (EXIT_FAILURE); } return (EXIT_SUCCESS); }
int main(int argc, char *argv[]) { try { Db *db = new Db(NULL, 0); db->open(NULL, "my.db", NULL, DB_BTREE, DB_CREATE, 0); // populate our massive database. // all our strings include null for convenience. // Note we have to cast for idiomatic // usage, since newer gcc requires it. set<string> hash; rand_init(); FILE*file=fopen("mydb","w"); for(int i=0;i<num_record;i++){ cout<<i<<endl; string str_key=rand_str(5,15); while(hash.count(str_key)!=0) str_key=rand_str(5,15); hash.insert(str_key); Dbt *keydbt = new Dbt((char *)str_key.c_str(), str_key.size()+1); string str_data=rand_str(150,250); Dbt *datadbt = new Dbt((char *)str_data.c_str(), str_data.size()+1); db->put(NULL, keydbt, datadbt, 0); fprintf(file,"%d\n%s\n%s\n",i,str_key.c_str(),str_data.c_str()); } fclose(file); db->close(0); }catch (DbException &dbe) { cerr << "Db Exception: " << dbe.what(); } return 0; }
Db * BDBBackend::get_db (const string & bucket) { Db * db = dbs[bucket]; if (!db) { u_int32_t db_flags = DB_AUTO_COMMIT; // allow auto-commit db = new Db (this->db_env, 0); try { db->open (NULL, // Txn pointer bucket.c_str (), // file name NULL, // logical db name DB_BTREE, // database type db_flags, // open flags 0); // file mode, defaults dbs[bucket] = db; } catch (DbException & e) { delete db; T_ERROR("get_db: exception=%s", e.what ()); ThrudocException de; de.what = "BDBBackend error"; throw de; } } return db; }
void process_results_callable::operator ()(Nids *nids, const char *db_filename) { Db db; if (db_filename && db_filename[0]) db.open(db_filename); while(true) { nids->process_result_sem.wait(); if (nids->threads_exit) break; if (db.is_opened()) nids->process_result(&db); else nids->process_result(NULL); } if (db_filename && db_filename[0]) db.close(); nids->threads_finished_sem.post(); BOOST_LOG_TRIVIAL(trace) << "process_result thread finished successfully" << endl; cout << "process result thread finished" << endl; }
Berkley(const string& dbname) :_env(0), _dbname(dbname) { _env.set_error_stream(&std::cerr); _env.open("/tmp/", DB_CREATE|DB_INIT_MPOOL,0); _db = new Db(&_env, 0); _db->open(nullptr, _dbname.c_str(), nullptr, DB_BTREE, DB_CREATE|DB_TRUNCATE, 0); };
void testDb(Db dbEngLab, Table *ptblTeacher) { DB_RET Ret; Ret = dbEngLab.open("EngLab", "D:\\Dropbox\\develop"); Ret = dbEngLab.addTable(ptblTeacher); Ret = dbEngLab.save(); Ret = dbEngLab.commit(); }
void test_new_open_delete() { system("rm -rf " DIR); toku_os_mkdir(DIR, 0777); DbEnv env(0); { int r = env.set_redzone(0); assert(r==0); } { int r = env.open(DIR, DB_INIT_MPOOL + DB_CREATE + DB_PRIVATE, 0777); assert(r == 0); } Db *db = new Db(&env, 0); assert(db != 0); { int r = db->open(NULL, FNAME, 0, DB_BTREE, DB_CREATE, 0777); assert(r == 0); } { int r = db->close(0); assert(r == 0); } delete db; }
int main(int argc, char *argv[]) { try { Db *db = new Db(NULL, 0); db->open(NULL, "my.db", NULL, DB_BTREE, DB_CREATE, 0644); // populate our massive database. // all our strings include null for convenience. // Note we have to cast for idiomatic // usage, since newer gcc requires it. Dbt *keydbt = new Dbt((char *)"key", 4); Dbt *datadbt = new Dbt((char *)"data", 5); db->put(NULL, keydbt, datadbt, 0); // Now, retrieve. We could use keydbt over again, // but that wouldn't be typical in an application. Dbt *goodkeydbt = new Dbt((char *)"key", 4); Dbt *badkeydbt = new Dbt((char *)"badkey", 7); Dbt *resultdbt = new Dbt(); resultdbt->set_flags(DB_DBT_MALLOC); int ret; if ((ret = db->get(NULL, goodkeydbt, resultdbt, 0)) != 0) { cout << "get: " << DbEnv::strerror(ret) << "\n"; } else { char *result = (char *)resultdbt->get_data(); cout << "got data: " << result << "\n"; } if ((ret = db->get(NULL, badkeydbt, resultdbt, 0)) != 0) { // We expect this... cout << "get using bad key: " << DbEnv::strerror(ret) << "\n"; } else { char *result = (char *)resultdbt->get_data(); cout << "*** got data using bad key!!: " << result << "\n"; } cout << "finished test\n"; } catch (DbException &dbe) { cerr << "Db Exception: " << dbe.what(); } return 0; }
int main(int argc, const char* argv[]) { if (argc !=3) { cout << "usage: "<< argv[0] << " <filename> <db filename>" << endl; return 1; } const char* kDatabaseName = argv[2]; const char* filename = argv[1]; DbEnv env(0); Db* pdb; try { env.set_error_stream(&cerr); env.open("./", DB_CREATE | DB_INIT_MPOOL, 0); pdb = new Db(&env, 0); pdb->set_flags(DB_DUP); // Create (or clear its content if it exists) the database pdb->open(NULL, kDatabaseName, NULL, DB_BTREE, DB_CREATE | DB_TRUNCATE, 0); readfile(pdb, filename); readfile(pdb, "tables/jp.txt"); // Clean up if (pdb != NULL) { pdb->close(0); delete pdb; } env.close(0); } catch (DbException& e) { cerr << "DbException: " << e.what() << endl; return -1; } catch (std::exception& e) { cerr << e.what() << endl; return -1; } return 0; }
// Note that any of the db calls can throw DbException void db_setup(const char *home, const char *data_dir, ostream& err_stream) { // // Create an environment object and initialize it for error // reporting. // DbEnv *dbenv = new DbEnv(0); dbenv->set_error_stream(&err_stream); dbenv->set_errpfx(progname); // // We want to specify the shared memory buffer pool cachesize, // but everything else is the default. // dbenv->set_cachesize(0, 64 * 1024, 0); // Databases are in a subdirectory. (void)dbenv->set_data_dir(data_dir); // Open the environment with full transactional support. dbenv->open(home, DB_CREATE | DB_INIT_LOCK | DB_INIT_LOG | DB_INIT_MPOOL | DB_INIT_TXN, 0); // Open a database in the environment to verify the data_dir // has been set correctly. // Create a database handle, using the environment. Db *db = new Db(dbenv, 0) ; // Open the database. db->open(NULL, "EvnExample_db1.db", NULL, DB_BTREE, DB_CREATE, 0644); // Close the database handle. db->close(0) ; delete db; // Close the handle. dbenv->close(0); delete dbenv; }
string BDBBackend::admin (const string & op, const string & data) { string ret = ThrudocBackend::admin (op, data); if (!ret.empty ()) { return ret; } else if (op == "create_bucket") { Db * db = NULL; try { db = get_db (data); // this will log an error message if db doesn't exist, ignore it } catch (ThrudocException e) {} if (!db) { T_INFO ("admin: creating db=%s", data.c_str()); u_int32_t db_flags = DB_CREATE | // allow creating db DB_AUTO_COMMIT; // allow auto-commit db = new Db (this->db_env, 0); db->open (NULL, // Txn pointer data.c_str (), // file name NULL, // logical db name DB_BTREE, // database type db_flags, // open flags 0); // file mode, defaults db->close (0); delete db; } return "done"; } // TODO delete_bucket, but have to figure out how to close the db // handles across all of the threads first... return ""; }
bool CDB::Rewrite(const string& strFile, const char* pszSkip) { while (!fShutdown) { { LOCK(bitdb.cs_db); if (!bitdb.mapFileUseCount.count(strFile) || bitdb.mapFileUseCount[strFile] == 0) { // Flush log data to the dat file bitdb.CloseDb(strFile); bitdb.CheckpointLSN(strFile); bitdb.mapFileUseCount.erase(strFile); bool fSuccess = true; printf("Rewriting %s...\n", strFile.c_str()); string strFileRes = strFile + ".rewrite"; { // surround usage of db with extra {} CDB db(strFile.c_str(), "r"); Db* pdbCopy = new Db(&bitdb.dbenv, 0); int ret = pdbCopy->open(NULL, // Txn pointer strFileRes.c_str(), // Filename "main", // Logical db name DB_BTREE, // Database type DB_CREATE, // Flags 0); if (ret > 0) { printf("Cannot create database file %s\n", strFileRes.c_str()); fSuccess = false; } Dbc* pcursor = db.GetCursor(); if (pcursor) while (fSuccess) { CDataStream ssKey(SER_DISK, CLIENT_VERSION); CDataStream ssValue(SER_DISK, CLIENT_VERSION); int ret = db.ReadAtCursor(pcursor, ssKey, ssValue, DB_NEXT); if (ret == DB_NOTFOUND) { pcursor->close(); break; } else if (ret != 0) { pcursor->close(); fSuccess = false; break; } if (pszSkip && strncmp(&ssKey[0], pszSkip, std::min(ssKey.size(), strlen(pszSkip))) == 0) continue; if (strncmp(&ssKey[0], "\x07version", 8) == 0) { // Update version: ssValue.clear(); ssValue << CLIENT_VERSION; } Dbt datKey(&ssKey[0], ssKey.size()); Dbt datValue(&ssValue[0], ssValue.size()); int ret2 = pdbCopy->put(NULL, &datKey, &datValue, DB_NOOVERWRITE); if (ret2 > 0) fSuccess = false; } if (fSuccess) { db.Close(); bitdb.CloseDb(strFile); if (pdbCopy->close(0)) fSuccess = false; delete pdbCopy; } } if (fSuccess) { Db dbA(&bitdb.dbenv, 0); if (dbA.remove(strFile.c_str(), NULL, 0)) fSuccess = false; Db dbB(&bitdb.dbenv, 0); if (dbB.rename(strFileRes.c_str(), NULL, strFile.c_str(), 0)) fSuccess = false; } if (!fSuccess) printf("Rewriting of %s FAILED!\n", strFileRes.c_str()); return fSuccess; } } MilliSleep(100); } return false; }
int main(int argc, const char* argv[]) { if (argc !=3) { cout << "usage: "<< argv[0] << " <filename> <db filename>" << endl; return 1; } const char* kDatabaseName = argv[2]; const char* filename = argv[1]; DbEnv env(0); Db* pdb; string line; try { env.set_error_stream(&cerr); env.open("./", DB_CREATE | DB_INIT_MPOOL, 0); pdb = new Db(&env, 0); // If you want to support duplicated records and make duplicated // records sorted by data, you need to call: // pdb->set_flags(DB_DUPSORT); // Note that only Btree-typed database supports sorted duplicated // records // If the database does not exist, create it. If it exists, clear // its content after openning. //pdb->set_flags( DB_DUP );// | DB_DUPSORT); pdb->open(NULL, kDatabaseName, NULL, DB_BTREE, DB_CREATE | DB_TRUNCATE, 0); ifstream myfile (filename); if (myfile.is_open()) { while ( myfile.good() ) { getline (myfile,line); // Ignore empty and commented lines if ((line.length() == 0) || (startswith(line, std::string("#")))) { continue; } std::vector<std::string> cj = split(line, ' '); int freq = atoi(cj[1].c_str()); Dbt key(const_cast<char*>(cj[0].data()), cj[0].size()); Dbt value(&freq, sizeof(int)); pdb->put(NULL, &key, &value, 0); } myfile.close(); } else { cout << "Unable to open file"; } // You need to set ulen and flags=DB_DBT_USERMEM to prevent Dbt // from allocate its own memory but use the memory provided by you. if (pdb != NULL) { pdb->close(0); delete pdb; } env.close(0); } catch (DbException& e) { cerr << "DbException: " << e.what() << endl; return -1; } catch (std::exception& e) { cerr << e.what() << endl; return -1; } return 0; }
// // Initialize the database to the specified number of accounts, branches, // history records, and tellers. // void TpcbExample::populate(int accounts, int branches, int history, int tellers) { Db *dbp; int err; u_int32_t balance, idnum; u_int32_t end_anum, end_bnum, end_tnum; u_int32_t start_anum, start_bnum, start_tnum; idnum = BEGID; balance = 500000; dbp = new Db(this, 0); dbp->set_h_nelem((unsigned int)accounts); if ((err = dbp->open(NULL, "account", NULL, DB_HASH, DB_CREATE, 0644)) != 0) { DbException except("Account file create failed", err); throw except; } start_anum = idnum; populateTable(dbp, idnum, balance, accounts, "account"); idnum += accounts; end_anum = idnum - 1; if ((err = dbp->close(0)) != 0) { DbException except("Account file close failed", err); throw except; } delete dbp; if (verbose) cout << "Populated accounts: " << (long)start_anum << " - " << (long)end_anum << "\n"; dbp = new Db(this, 0); // // Since the number of branches is very small, we want to use very // small pages and only 1 key per page. This is the poor-man's way // of getting key locking instead of page locking. // dbp->set_h_ffactor(1); dbp->set_h_nelem((unsigned int)branches); dbp->set_pagesize(512); if ((err = dbp->open(NULL, "branch", NULL, DB_HASH, DB_CREATE, 0644)) != 0) { DbException except("Branch file create failed", err); throw except; } start_bnum = idnum; populateTable(dbp, idnum, balance, branches, "branch"); idnum += branches; end_bnum = idnum - 1; if ((err = dbp->close(0)) != 0) { DbException except("Close of branch file failed", err); throw except; } delete dbp; if (verbose) cout << "Populated branches: " << (long)start_bnum << " - " << (long)end_bnum << "\n"; dbp = new Db(this, 0); // // In the case of tellers, we also want small pages, but we'll let // the fill factor dynamically adjust itself. // dbp->set_h_ffactor(0); dbp->set_h_nelem((unsigned int)tellers); dbp->set_pagesize(512); if ((err = dbp->open(NULL, "teller", NULL, DB_HASH, DB_CREATE, 0644)) != 0) { DbException except("Teller file create failed", err); throw except; } start_tnum = idnum; populateTable(dbp, idnum, balance, tellers, "teller"); idnum += tellers; end_tnum = idnum - 1; if ((err = dbp->close(0)) != 0) { DbException except("Close of teller file failed", err); throw except; } delete dbp; if (verbose) cout << "Populated tellers: " << (long)start_tnum << " - " << (long)end_tnum << "\n"; dbp = new Db(this, 0); dbp->set_re_len(HISTORY_LEN); if ((err = dbp->open(NULL, "history", NULL, DB_RECNO, DB_CREATE, 0644)) != 0) { DbException except("Create of history file failed", err); throw except; } populateHistory(dbp, history, accounts, branches, tellers); if ((err = dbp->close(0)) != 0) { DbException except("Close of history file failed", err); throw except; } delete dbp; }
int main() { u_int32_t env_flags = DB_CREATE | DB_INIT_LOCK | DB_INIT_LOG | DB_INIT_MPOOL | DB_INIT_TXN; const char* home = "envHome"; u_int32_t db_flags = DB_CREATE | DB_AUTO_COMMIT; const char* fileName = "envtest.db"; Db* dbp = NULL; DbEnv myEnv(0); try{ myEnv.open(home,env_flags,0); myEnv.set_flags(DB_MULTIVERSION,1); dbp = new Db(&myEnv,0); dbp->open( NULL, //Txn pointer fileName, //File name NULL, //Logic db name DB_BTREE, //Database type db_flags, //Open flags 0 //file mode ); }catch(DbException &e){ std::cerr<<"Error when opening database and Environment:" <<fileName<<","<<home<<std::endl; std::cerr<<e.what()<<std::endl; } //put data normally char *key1 = "luffy"; char *data1 = "op"; char *key2= "usopp"; char *data2 = "brave"; Dbt pkey1(key1,strlen(key1)+1); Dbt pdata1(data1,strlen(data1)+1); Dbt pkey2(key2,strlen(key2)+1); Dbt pdata2(data2,strlen(data2)+1); dbp->put(NULL,&pkey1,&pdata1,0); dbp->put(NULL,&pkey2,&pdata2,0); //using txn cursor to read and another cursor to modify before commit try{ DbTxn *txn1 = NULL; myEnv.txn_begin(NULL,&txn1,DB_TXN_SNAPSHOT); Dbc *cursorp = NULL; dbp->cursor(txn1,&cursorp,0); Dbt tempData1,tempKey2,tempData2; tempData2.set_flags(DB_DBT_MALLOC); cursorp->get(&pkey1,&tempData1,DB_SET); cursorp->get(&tempKey2,&tempData2,DB_NEXT); //cout just to see if it is right std::cout<<(char*)pkey1.get_data()<<" : "<<(char*)tempData1.get_data()<<std::endl <<(char*)tempKey2.get_data()<<" : "<<(char*)tempData2.get_data()<<std::endl; //we can ignore the lock when operation in //the same transaction dbp->put(NULL,&pkey1,&pdata2,0); dbp->put(NULL,&pkey2,&pdata1,0); //will not block even cursor still on this page //close cursor cursorp->close(); //commit the txn txn1->commit(0); }catch(DbException &e){ std::cerr<<"Error when use a txn"<<std::endl; } try{ dbp->close(0); //dbp should close before environment myEnv.close(0); }catch(DbException &e){ std::cerr<<"Error when closing database and environment:" <<fileName<<","<<home<<std::endl; std::cerr<<e.what()<<std::endl; } return 0; }
int RepMgrGSG::doloop() { Dbt key, data; Db *dbp; char buf[BUFSIZE], *rbuf; int ret; dbp = 0; memset(&key, 0, sizeof(key)); memset(&data, 0, sizeof(data)); ret = 0; for (;;) { if (dbp == 0) { dbp = new Db(&dbenv, 0); try { dbp->open(NULL, DATABASE, NULL, DB_BTREE, app_data.is_master ? DB_CREATE | DB_AUTO_COMMIT : DB_AUTO_COMMIT, 0); } catch(DbException dbe) { // It is expected that this condition will be triggered // when client sites start up. It can take a while for // the master site to be found and synced, and no DB will // be available until then. if (dbe.get_errno() == ENOENT) { cout << "No stock db available yet - retrying." << endl; try { dbp->close(0); } catch (DbException dbe2) { cout << "Unexpected error closing after failed" << " open, message: " << dbe2.what() << endl; dbp = NULL; goto err; } dbp = NULL; sleep(SLEEPTIME); continue; } else { dbenv.err(ret, "DB->open"); throw dbe; } } } cout << "QUOTESERVER" ; if (!app_data.is_master) cout << "(read-only)"; cout << "> " << flush; if (fgets(buf, sizeof(buf), stdin) == NULL) break; if (strtok(&buf[0], " \t\n") == NULL) { switch ((ret = print_stocks(dbp))) { case 0: continue; case DB_REP_HANDLE_DEAD: (void)dbp->close(DB_NOSYNC); cout << "closing db handle due to rep handle dead" << endl; dbp = NULL; continue; default: dbp->err(ret, "Error traversing data"); goto err; } } rbuf = strtok(NULL, " \t\n"); if (rbuf == NULL || rbuf[0] == '\0') { if (strncmp(buf, "exit", 4) == 0 || strncmp(buf, "quit", 4) == 0) break; dbenv.errx("Format: TICKER VALUE"); continue; } if (!app_data.is_master) { dbenv.errx("Can't update at client"); continue; } key.set_data(buf); key.set_size((u_int32_t)strlen(buf)); data.set_data(rbuf); data.set_size((u_int32_t)strlen(rbuf)); if ((ret = dbp->put(NULL, &key, &data, 0)) != 0) { dbp->err(ret, "DB->put"); if (ret != DB_KEYEXIST) goto err; } } err: if (dbp != 0) { (void)dbp->close(DB_NOSYNC); } return (ret); }
// // Initialize the database to the specified number of accounts, branches, // history records, and tellers. // void StlTpcbExample::populate(int accounts, int branches, int history, int tellers) { Db *dbp; DefrecMap *accounts_map, *branches_map, *tellers_map; HistrecVector *history_vector; int err, oflags; u_int32_t balance, idnum; u_int32_t end_anum, end_bnum, end_tnum; u_int32_t start_anum, start_bnum, start_tnum; idnum = BEGID; balance = 500000; oflags = DB_CREATE; dbp = new Db(this, DB_CXX_NO_EXCEPTIONS); dbp->set_h_nelem((unsigned int)accounts); if ((err = dbp->open(NULL, "account", NULL, DB_HASH, oflags, 0644)) != 0) { DbException except("Account file create failed", err); throw except; } dbstl::register_db(dbp); accounts_map = new DefrecMap(dbp, this); start_anum = idnum; populateTable(accounts_map, idnum, balance, accounts, "account"); idnum += accounts; end_anum = idnum - 1; // Automatically closes the underlying database. delete accounts_map; dbstl::close_db(dbp); delete dbp; if (verbose) cout << "Populated accounts: " << (long)start_anum << " - " << (long)end_anum << "\n"; dbp = new Db(this, DB_CXX_NO_EXCEPTIONS); // // Since the number of branches is very small, we want to use very // small pages and only 1 key per page. This is the poor-man's way // of getting key locking instead of page locking. // dbp->set_h_ffactor(1); dbp->set_h_nelem((unsigned int)branches); dbp->set_pagesize(512); if ((err = dbp->open(NULL, "branch", NULL, DB_HASH, oflags, 0644)) != 0) { DbException except("Branch file create failed", err); throw except; } dbstl::register_db(dbp); branches_map = new DefrecMap(dbp, this); start_bnum = idnum; populateTable(branches_map, idnum, balance, branches, "branch"); idnum += branches; end_bnum = idnum - 1; delete branches_map; dbstl::close_db(dbp); delete dbp; if (verbose) cout << "Populated branches: " << (long)start_bnum << " - " << (long)end_bnum << "\n"; dbp = new Db(this, DB_CXX_NO_EXCEPTIONS); // // In the case of tellers, we also want small pages, but we'll let // the fill factor dynamically adjust itself. // dbp->set_h_ffactor(0); dbp->set_h_nelem((unsigned int)tellers); dbp->set_pagesize(512); if ((err = dbp->open(NULL, "teller", NULL, DB_HASH, oflags, 0644)) != 0) { DbException except("Teller file create failed", err); throw except; } dbstl::register_db(dbp); tellers_map = new DefrecMap(dbp, this); start_tnum = idnum; populateTable(tellers_map, idnum, balance, tellers, "teller"); idnum += tellers; end_tnum = idnum - 1; delete tellers_map; dbstl::close_db(dbp); delete dbp; if (verbose) cout << "Populated tellers: " << (long)start_tnum << " - " << (long)end_tnum << "\n"; dbp = new Db(this, DB_CXX_NO_EXCEPTIONS); dbp->set_re_len(HISTORY_LEN); if ((err = dbp->open(NULL, "history", NULL, DB_RECNO, oflags, 0644)) != 0) { DbException except("Create of history file failed", err); throw except; } dbstl::register_db(dbp); history_vector = new HistrecVector(dbp, this); populateHistory(history_vector, history, accounts, branches, tellers); delete history_vector; dbstl::close_db(dbp); delete dbp; }
bool CDB::Rewrite(const string& strFile, BerkerleyDBUpgradeProgress &progress, const char* pszSkip, int previousVer, int currentVer) { while (!fShutdown) { { LOCK(bitdb.cs_db); if (!bitdb.mapFileUseCount.count(strFile) || bitdb.mapFileUseCount[strFile] == 0) { // Flush log data to the dat file bitdb.CloseDb(strFile); bitdb.CheckpointLSN(strFile); bitdb.mapFileUseCount.erase(strFile); bool fSuccess = true; printf("Rewriting %s...\n", strFile.c_str()); string strFileRes = strFile + ".rewrite"; { // surround usage of db with extra {} CDB db(strFile.c_str(), "r"); Db* pdbCopy = new Db(&bitdb.dbenv, 0); int ret = pdbCopy->open(NULL, // Txn pointer strFileRes.c_str(), // Filename "main", // Logical db name DB_BTREE, // Database type DB_CREATE, // Flags 0); if (ret > 0) { printf("Cannot create database file %s\n", strFileRes.c_str()); fSuccess = false; } Dbc* pcursor = db.GetCursor(); if (pcursor) nTotalBytesCompleted = 0; nProgressPercent = 0; int numRows = 0; CDataStream ssKey(SER_DISK, CLIENT_VERSION); CDataStream ssValue(SER_DISK, CLIENT_VERSION); while (fSuccess) { int ret = db.ReadAtCursor(pcursor, ssKey, ssValue, DB_NEXT); if (ret == DB_NOTFOUND) { pcursor->close(); break; } else if (ret != 0) { pcursor->close(); fSuccess = false; break; } numRows++; } db.ReadAtCursor(pcursor, ssKey, ssValue, DB_FIRST); nTotalBytes = numRows; // Set up progress calculations and callbacks. callbackTotalOperationProgress = &progress; ExternalBlockFileProgress callbackProgress; callbackProgress.connect(RewriteProgress); (*callbackTotalOperationProgress)(0.0); fSuccess = true; while (fSuccess) { CDataStream ssKey(SER_DISK, CLIENT_VERSION); CDataStream ssValue(SER_DISK, CLIENT_VERSION); int ret = db.ReadAtCursor(pcursor, ssKey, ssValue, DB_NEXT); if (ret == DB_NOTFOUND) { pcursor->close(); break; } else if (ret != 0) { pcursor->close(); fSuccess = false; break; } /* if (strncmp(&ssKey[0], "\x02tx", 3) != 0) { char* k = &ssKey[0]; int xx = 1; } */ if (pszSkip && strncmp(&ssKey[0], pszSkip, std::min(ssKey.size(), strlen(pszSkip))) == 0) continue; if (strncmp(&ssKey[0], "\x07version", 8) == 0) { // Update version: ssValue.clear(); ssValue << currentVer; } // update blockindex to include block hash if (previousVer <= DB_MINVER_INCHASH && strncmp(&ssKey[0], "\nblockindex", 11) == 0) { CDiskBlockIndex diskindex(DB_PREV_VER); ssValue >> diskindex; diskindex.fileVersion = CLIENT_VERSION; // update version /* // Construct block index object CBlockIndex* pindexNew = InsertBlockIndex(blockHash); pindexNew->pprev = InsertBlockIndex(diskindex.hashPrev); pindexNew->pnext = InsertBlockIndex(diskindex.hashNext); pindexNew->nFile = diskindex.nFile; pindexNew->nBlockPos = diskindex.nBlockPos; pindexNew->nHeight = diskindex.nHeight; pindexNew->nMint = diskindex.nMint; pindexNew->nMoneySupply = diskindex.nMoneySupply; pindexNew->nFlags = diskindex.nFlags; pindexNew->nStakeModifier = diskindex.nStakeModifier; pindexNew->prevoutStake = diskindex.prevoutStake; pindexNew->nStakeTime = diskindex.nStakeTime; pindexNew->hashProofOfStake = diskindex.hashProofOfStake; pindexNew->nVersion = diskindex.nVersion; pindexNew->hashMerkleRoot = diskindex.hashMerkleRoot; pindexNew->nTime = diskindex.nTime; pindexNew->nBits = diskindex.nBits; pindexNew->nNonce = diskindex.nNonce; */ uint256 blockHash = diskindex.GetBlockHash(); // calc hash (force) ssValue << diskindex; // serialize } Dbt datKey(&ssKey[0], ssKey.size()); Dbt datValue(&ssValue[0], ssValue.size()); (callbackProgress)(1); int ret2 = pdbCopy->put(NULL, &datKey, &datValue, DB_NOOVERWRITE); if (ret2 > 0) fSuccess = false; } if (fSuccess) { db.Close(); bitdb.CloseDb(strFile); if (pdbCopy->close(0)) fSuccess = false; delete pdbCopy; } } if (fSuccess) { Db dbA(&bitdb.dbenv, 0); if (dbA.remove(strFile.c_str(), NULL, 0)) fSuccess = false; Db dbB(&bitdb.dbenv, 0); if (dbB.rename(strFileRes.c_str(), NULL, strFile.c_str(), 0)) fSuccess = false; } if (!fSuccess) printf("Rewriting of %s FAILED!\n", strFileRes.c_str()); return fSuccess; } }
// Note that any of the db calls can throw DbException void db_setup(const char *home, const char *data_dir, ostream& err_stream) { const char * err1 = "DbEnv::open: No such file or directory"; const char * err2 = "Db::open: No such file or directory"; // // Create an environment object and initialize it for error // reporting. // DbEnv *dbenv = new DbEnv(0); dbenv->set_error_stream(&err_stream); dbenv->set_errpfx(progname); // // We want to specify the shared memory buffer pool cachesize, // but everything else is the default. // dbenv->set_cachesize(0, 64 * 1024, 0); // Databases are in a subdirectory. (void)dbenv->set_data_dir(data_dir); // Open the environment with full transactional support. try { dbenv->open(home, DB_CREATE | DB_INIT_LOCK | DB_INIT_LOG | DB_INIT_MPOOL | DB_INIT_TXN, 0); } catch (DbException &dbe) { cerr << "EnvExample: " << dbe.what() << "\n"; if (!strcmp(dbe.what(), err1)){ cout << "Please check whether " << "home dir \"" << home << "\" exists.\n"; } exit (-1); } // Open a database in the environment to verify the data_dir // has been set correctly. // Create a database handle, using the environment. Db *db = new Db(dbenv, 0) ; // Open the database. try { db->open(NULL, "EvnExample_db1.db", NULL, DB_BTREE, DB_CREATE, 0644); } catch (DbException &dbe) { cerr << "EnvExample: " << dbe.what() << "\n"; if (!strcmp(dbe.what(), err2)){ cout << "Please check whether data dir \"" << data_dir << "\" exists under \"" << home << "\"\n"; } exit (-1); } // Close the database handle. db->close(0) ; delete db; // Close the handle. dbenv->close(0); delete dbenv; }
static void transformDb(bool evictor, const Ice::CommunicatorPtr& communicator, const FreezeScript::ObjectFactoryPtr& objectFactory, DbEnv& dbEnv, DbEnv& dbEnvNew, const string& dbName, const Freeze::ConnectionPtr& connectionNew, vector<Db*>& dbs, const Slice::UnitPtr& oldUnit, const Slice::UnitPtr& newUnit, DbTxn* txnNew, bool purgeObjects, bool suppress, string descriptors) { if(evictor) { // // The evictor database file contains multiple databases. We must first // determine the names of those databases, ignoring any whose names // begin with "$index:". Each database represents a separate facet, with // the facet name used as the database name. The database named "$default" // represents the main object. // vector<string> dbNames; { Db db(&dbEnv, 0); db.open(0, dbName.c_str(), 0, DB_UNKNOWN, DB_RDONLY, 0); Dbt dbKey, dbValue; dbKey.set_flags(DB_DBT_MALLOC); dbValue.set_flags(DB_DBT_USERMEM | DB_DBT_PARTIAL); Dbc* dbc = 0; db.cursor(0, &dbc, 0); while(dbc->get(&dbKey, &dbValue, DB_NEXT) == 0) { string s(static_cast<char*>(dbKey.get_data()), dbKey.get_size()); if(s.find("$index:") != 0) { dbNames.push_back(s); } free(dbKey.get_data()); } dbc->close(); db.close(0); } // // Transform each database. We must delay closing the new databases // until after the transaction is committed or aborted. // for(vector<string>::iterator p = dbNames.begin(); p != dbNames.end(); ++p) { string name = p->c_str(); Db db(&dbEnv, 0); db.open(0, dbName.c_str(), name.c_str(), DB_BTREE, DB_RDONLY, FREEZE_SCRIPT_DB_MODE); Db* dbNew = new Db(&dbEnvNew, 0); dbs.push_back(dbNew); dbNew->open(txnNew, dbName.c_str(), name.c_str(), DB_BTREE, DB_CREATE | DB_EXCL, FREEZE_SCRIPT_DB_MODE); // // Execute the transformation descriptors. // istringstream istr(descriptors); string facet = (name == "$default" ? string("") : name); FreezeScript::transformDatabase(communicator, objectFactory, oldUnit, newUnit, &db, dbNew, txnNew, 0, dbName, facet, purgeObjects, cerr, suppress, istr); db.close(0); } Freeze::Catalog catalogNew(connectionNew, Freeze::catalogName()); Freeze::CatalogData catalogData = { true, "::Ice::Identity", "Object" }; catalogNew.put(Freeze::Catalog::value_type(dbName, catalogData)); } else { // // Transform a map database. // Db db(&dbEnv, 0); db.open(0, dbName.c_str(), 0, DB_BTREE, DB_RDONLY, FREEZE_SCRIPT_DB_MODE); Db* dbNew = new Db(&dbEnvNew, 0); dbs.push_back(dbNew); dbNew->open(txnNew, dbName.c_str(), 0, DB_BTREE, DB_CREATE | DB_EXCL, FREEZE_SCRIPT_DB_MODE); // // Execute the transformation descriptors. // istringstream istr(descriptors); FreezeScript::transformDatabase(communicator, objectFactory, oldUnit, newUnit, &db, dbNew, txnNew, connectionNew, dbName, "", purgeObjects, cerr, suppress, istr); db.close(0); } }
int main(int argc, const char* argv[]) { if (argc !=3) { cout << "usage: "<< argv[0] << " <filename> <db filename>" << endl; return 1; } const char* kDatabaseName = argv[2]; const char* filename = argv[1]; DbEnv env(0); Db* pdb; string line; bool datamode = false; try { env.set_error_stream(&cerr); env.open("./", DB_CREATE | DB_INIT_MPOOL, 0); pdb = new Db(&env, 0); // If you want to support duplicated records and make duplicated // records sorted by data, you need to call: // pdb->set_flags(DB_DUPSORT); // Note that only Btree-typed database supports sorted duplicated // records // If the database does not exist, create it. If it exists, clear // its content after openning. pdb->set_flags( DB_DUP );// | DB_DUPSORT); pdb->open(NULL, kDatabaseName, NULL, DB_BTREE, DB_CREATE | DB_TRUNCATE, 0); ifstream myfile (filename); if (myfile.is_open()) { int count = 0; while ( myfile.good() ) { //if (count++ > 10) { // break; //} getline (myfile,line); if (!datamode) { if ("[DATA]" == line ) { datamode = true; } continue; } //cout << (int)line[8] << endl; int index = 0; while (32 != (char)line[index]) { index++; } string cjkey = line.substr(0, index); while (32 == line[index]) { index++; } string cjdata = line.substr(index, (line.size()-index)); cout << cjkey << "---" << cjdata << endl; Dbt key(const_cast<char*>(cjkey.data()), cjkey.size()); Dbt value(const_cast<char*>(cjdata.data()), cjdata.size()); pdb->put(NULL, &key, &value, 0); } myfile.close(); } else { cout << "Unable to open file"; } // You need to set ulen and flags=DB_DBT_USERMEM to prevent Dbt // from allocate its own memory but use the memory provided by you. string search("aa"); Dbt key(const_cast<char*>(search.c_str()), search.size()); char buffer[1024]; Dbt data; data.set_data(buffer); data.set_ulen(1024); data.set_flags(DB_DBT_USERMEM); if (pdb->get(NULL, &key, &data, 0) == DB_NOTFOUND) { cerr << "Not found" << endl; } else { cout << "Found: " << "PPPPPP" <<buffer << "PPPPPP" << endl; } if (pdb != NULL) { pdb->close(0); delete pdb; // You have to close and delete an exisiting handle, then create // a new one before you can use it to remove a database (file). pdb = new Db(NULL, 0); //pdb->remove("access.db", NULL, 0); delete pdb; } env.close(0); } catch (DbException& e) { cerr << "DbException: " << e.what() << endl; return -1; } catch (std::exception& e) { cerr << e.what() << endl; return -1; } return 0; }
int RepMgr::doloop() { Db *dbp; Dbt key, data; char buf[BUFSIZE], *rbuf; int ret; dbp = NULL; memset(&key, 0, sizeof(key)); memset(&data, 0, sizeof(data)); ret = 0; for (;;) { if (dbp == NULL) { dbp = new Db(&dbenv, 0); try { dbp->open(NULL, DATABASE, NULL, DB_BTREE, DB_CREATE | DB_AUTO_COMMIT, 0); } catch(DbException dbe) { dbenv.err(ret, "DB->open"); throw dbe; } } cout << "QUOTESERVER" ; cout << "> " << flush; if (fgets(buf, sizeof(buf), stdin) == NULL) break; if (strtok(&buf[0], " \t\n") == NULL) { switch ((ret = print_stocks(dbp))) { case 0: continue; default: dbp->err(ret, "Error traversing data"); goto err; } } rbuf = strtok(NULL, " \t\n"); if (rbuf == NULL || rbuf[0] == '\0') { if (strncmp(buf, "exit", 4) == 0 || strncmp(buf, "quit", 4) == 0) break; dbenv.errx("Format: TICKER VALUE"); continue; } key.set_data(buf); key.set_size((u_int32_t)strlen(buf)); data.set_data(rbuf); data.set_size((u_int32_t)strlen(rbuf)); if ((ret = dbp->put(NULL, &key, &data, 0)) != 0) { dbp->err(ret, "DB->put"); if (ret != DB_KEYEXIST) goto err; } } err: if (dbp != NULL) (void)dbp->close(DB_NOSYNC); return (ret); }
int main() { u_int32_t env_flags = DB_CREATE | // If the environment does not exist, create it. DB_INIT_MPOOL; // Initialize the in-memory cache. //std::string envHome("./"); std::string envHome("/home/kirill"); u_int32_t db_flags = DB_RDONLY; // only read std::string dbName("X-po2s.db"); //std::string dbName("X-so2p.db"); //std::string dbName("X-sp2o.db"); DbEnv myEnv(0); Db *myDb; // Instantiate the Db object Dbc *cursorp; // cursor try { cout << "X-po2s.db output:" << endl; myEnv.open(envHome.c_str(), env_flags, 0); myDb = new Db(&myEnv, 0); myDb->open(NULL, dbName.c_str(), NULL, DB_BTREE, db_flags, 0); // Get a cursor myDb->cursor(NULL, &cursorp, 0); Dbt key, data; // Position the cursor to the first record in the database whose // key and data begin with the correct strings. int ret = cursorp->get(&key, &data, DB_NEXT); while (ret != DB_NOTFOUND) { cout << "..." << endl; std::cout << "key: " << (char *)key.get_data() << "data: " << (char *)data.get_data()<< std::endl; ret = cursorp->get(&key, &data, DB_NEXT); } // Cursors must be closed if (cursorp != NULL) cursorp->close(); if (myDb != NULL) { myDb->close(0); } myEnv.close(0); cout << "Closing ..." << endl; } // Must catch both DbException and std::exception catch(DbException &e) { myDb->err(e.get_errno(), "Database open failed %s", dbName.c_str()); throw e; } catch(std::exception &e) { // No DB error number available, so use errx myDb->errx("Error opening database: %s", e.what()); throw e; } return 0; }