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