Tstdb Class Reference

Simple Transactional DataBase. More...

Collaboration diagram for Tstdb:

[legend]List of all members.

Public Member Functions
	Tstdb (const char *TCDBName, const char *TCDBLogName, const int ParMaxLogSize, const int ParMaxTime)
void	Initialize (void)
bool	Insert (char *key, unsigned int lkey, char *data, unsigned int ldata)
bool	Update (char *key, unsigned int lkey, char *data, unsigned int ldata)
bool	Fetch (char *key, unsigned int lkey, const char **data, unsigned int *ldata)
bool	Delete (char *key, unsigned int lkey)
bool	Commit (void)
bool	Reorganize ()
bool	Rollback (void)
bool	Firstkey (const char **key, unsigned int *lkey, const char **data, unsigned int *ldata)
bool	Nextkey (const char **key, unsigned int *lkey, const char **data, unsigned int *ldata)
bool	Getstatus (int *LogStatus, int *CDBStatus)
void	Finalize (void)
	~Tstdb ()
Private Types
typedef map< string, string, less< string > >	TDBMemory
typedef TDBMemory::value_type	TValue
enum	{ LogOK, LogCORRUPTION, LogNOFILE }
enum	{ CDBOK, CDBCORRUPTION, CDBNOFILE }
enum	TFunction { INSERT, UPDATE, DELETE }
Private Member Functions
bool	Getcdbline (ifstream &in, TAction &action, bool &final)
bool	Getlogline (ifstream &in, TAction &action, bool &commit, int &size, bool &final)
bool	Getline (ifstream &in, TAction &action, int &size)
bool	ParserLineOut (string &line, TAction &action)
bool	ParserLineDeleteOut (string &line, TAction &action)
bool	ReorganizeNecessary ()
Private Attributes
char *	db
char *	log
int	MaxLogSize
int	MaxTime
TDBMemory	DBMemory
TDBMemory::iterator	index
enum Tstdb:: { ... }	OpenLogStatus
enum Tstdb:: { ... }	OpenCDBStatus
int	ReadBytes
stack< TAction, vector< TAction > >	RollBack
queue< TAction, list< TAction > >	RedoLog
Classes
class	TAction
	Class TAction to contain an action to be done. More...

---

Detailed Description

The Core Class: the database will be stored in memory inside an Tstdb object.

Definition at line 94 of file stdb.h.

---

Member Typedef Documentation

typedef map<string,string,less<string> > Tstdb::TDBMemory [private]

TDBMemory type definition. The database is read from the db file to memory and it is stored into the object DBMemory, a TDBMemory map containing key/value pairs. Definition at line 123 of file stdb.h.

typedef TDBMemory::value_type Tstdb::TValue [private]

TValue type definition. This is an abstraction of every single object inside the DBMemory map. Definition at line 129 of file stdb.h.

---

Member Enumeration Documentation

anonymous enum [private]

Log file possible status. OpenLogStatus indicates the LOG file status, which could be correct corrupted or not existing, resp. Definition at line 149 of file stdb.h. {LogOK, LogCORRUPTION, LogNOFILE} OpenLogStatus;

anonymous enum [private]

Database file possible status. OpenCDBStatus reports the DB file status: OK, CORRUPTED OR NOT EXISTING. Definition at line 156 of file stdb.h. {CDBOK, CDBCORRUPTION, CDBNOFILE} OpenCDBStatus;

enum Tstdb::TFunction [private]

These are possible TAction actions to be done. Definition at line 166 of file stdb.h. { INSERT, UPDATE, DELETE };

---

Constructor & Destructor Documentation

Tstdb::Tstdb (  const char *  TCDBName, const char *  TCDBLogName, const int  ParMaxLogSize, const int  ParMaxTime )

Constructor Tstdb. Features: Truncate the log file if bad format founded Autodetection of cdb remake operation interrumped Parameters: TCDBName  Name of cdb file TCDBLogName  Name of log file ParMaxLogSize  Maximun log size to remake the cdbfile ParMaxTime  Max time between cdb and log files to remake db Returns: The Database Object Definition at line 68 of file stdb.cpp. References db, Initialize(), log, MaxLogSize, and MaxTime. { // MaxLongLog MaxLogSize = ParMaxLogSize; // MaxTime MaxTime = ParMaxTime * 24 * 60 * 60; //In seconds // Save the path files db=strdup(TCDBName); log=strdup(TCDBLogName); // Transfer database information from files to memory Initialize(); }

Tstdb::~Tstdb (   )

Destructor Tstdb. Definition at line 785 of file stdb.cpp. { }

---

Member Function Documentation

bool Tstdb::Commit (  void   )

Commit transaction. Validate current transaction, beginning of the next one is implicit. It's essential to assure transaction integrity. Returns: False if anything's wrong Definition at line 508 of file stdb.cpp. References Tstdb::TAction::GetFunction(), log, ParserLineDeleteOut(), ParserLineOut(), RedoLog, ReorganizeNecessary(), and RollBack. { // Are there movements to log? if(RedoLog.empty()) return true; // Transfer the redolog // queue to LOG file ofstream logOut(log, ios::out|ios::app); while(!RedoLog.empty()){ TAction &action = RedoLog.front(); switch(action.GetFunction()){ case INSERT: case UPDATE:{ // Parser line out: // Output formatting string buffer; ParserLineOut(buffer, action); // Writting line into LOG file logOut << buffer; break; } case DELETE:{ // Parser Delete line out: // Output formatting string buffer; ParserLineDeleteOut(buffer, action); // Writting line into log file logOut << buffer; break; } } RedoLog.pop(); } // Intro COMMIT constant before // closing LOG file logOut << COMMIT << endl; // Flushing the buffer logOut.flush(); // Erase the RollBack stack // Pop all Actions from stack while(!RollBack.empty()) RollBack.pop(); // Verify if Reorganize() is necessary ReorganizeNecessary(); return true; }

bool Tstdb::Delete (  char *  key, unsigned int  lkey )

Delete key/value pair from database. Parameters: key  Key to be deleted lkey  Size of deleted key Returns: False if key do not exists Definition at line 477 of file stdb.cpp. References DBMemory, RedoLog, and RollBack. { string keys(key,key+lkey); // Search (key,data) into memory map TDBMemory::iterator p = DBMemory.find(keys); if (p != DBMemory.end()){ // Key found // Pushing an Insert to the RollBack stack TAction action1(INSERT, keys, p->second); RollBack.push(action1); // Pushing a Delete to the RedoLog queue TAction action2(DELETE, keys, ""); RedoLog.push(action2); // Erasing (key,data) from map object DBMemory.erase(keys); return true; } else{ // Not found // Nothing to do here return false; } }

bool Tstdb::Fetch (  char *  key, unsigned int  lkey, const char **  data, unsigned int *  ldata )

Fetch the value for a given key from the database. Parameters: key  Key to be fetched lkey  Size of the fetched key data  Returns a pointer to data ldata  Returns a pointer to size of data Returns: False if key do not exists Definition at line 456 of file stdb.cpp. References DBMemory. { string keys(key,key+lkey); // Search (key,data) into memory map TDBMemory::iterator p = DBMemory.find(keys); if (p != DBMemory.end()){ // Key has been found *ldata = p->second.length(); *data = p->second.c_str(); return true; } else{ // Key has not been found return false; } }

void Tstdb::Finalize (  void   )

Finalize: deletes the DB and LOG file. It's not clear... why to delete these?

bool Tstdb::Firstkey (  const char **  key, unsigned int *  lkey, const char **  data, unsigned int *  ldata )

Find first key in database. Parameters: key  Returns a pointer to the first key lkey  Returns a pointer to the size of the first key data  Returns a pointer to the data of the first key ldata  Returns a pointer to size of data of the 1st key Returns: False if anything's wrong Definition at line 730 of file stdb.cpp. References DBMemory, and index. { // Iterator at the beginning of the map index = DBMemory.begin(); // Verify if there are elements if (index == DBMemory.end()) return false; *lkey = index->first.length(); *key = index->first.c_str(); *ldata = index->second.length(); *data = index->second.c_str(); index++; return true; }

bool Tstdb::Getcdbline (  ifstream &  in, TAction &  action, bool &  final )  [private]

Parser Get database file lines. Getcdbline is designed to read an entry from the database file and recover the action it stores. Parameters: in  The stream we are reading from action  The action returned by reference final  Indicates if it's the end Returns: True if DB line recovery went OK Definition at line 234 of file stdb.cpp. References Getline(). Referenced by Initialize(). { // "+" check char c; in.get(c); if (in.eof()) return false; if (c=='\n'){ final=true; in.get(c); return true; } final=false; if(c!='+') return false; int size; return Getline(in, action, size); }

bool Tstdb::Getline (  ifstream &  in, TAction &  action, int &  size )  [private]

Parser generic Get line. Getline is designed to read a formatted entry from both the DB and the LOG file. It is called from Getcdbline and Getlogline functions. Parameters: in  The stream we are reading from action  The action returned by reference size  The size of read entry Returns: True if line recovery went OK Definition at line 293 of file stdb.cpp. Referenced by Getcdbline(), and Getlogline(). { // Key long char buffer[BUFFSIZE],c; size=1; // Start with '+' character, counts one byte in.get(buffer, BUFFSIZE, ','); int lkey; lkey = atol(buffer); size+=strlen(buffer); in.get(c); if (in.eof()) return false; if(c!=',') return false; size+=1; // Data long int ldata; in.get(buffer, BUFFSIZE, ':'); if (in.eof()) return false; if(buffer[0]=='-'){ // It's a deleted key in.get(buffer[1]); if (in.eof()) return false; if(buffer[1]=='1'){ ldata=0; size+=2; } else{ // Format error return false; } } else{ // Usual key if (in.eof()) return false; ldata = atol(buffer); size+=strlen(buffer); } in.get(c); if (in.eof()) return false; if(c!=':') return false; size+=1; // Get key in.read(buffer, lkey); if (in.eof()) return false; string keys(buffer, buffer+lkey); size+=lkey; // Get "->" in.get(c); if (in.eof()) return false; if(c!='-') return false; in.get(c); if (in.eof()) return false; if(c!='>') return false; size+=2; // Get data if(ldata == 0){ // Deleted key TAction action1(DELETE,keys,""); action=action1; } else{ // Usual key in.read(buffer, ldata); string datas(buffer, buffer+ldata); TAction action1(INSERT,keys,datas); action=action1; } size+=ldata; // Get '\n', end of line/entry in.get(c); if (in.eof()) return false; if(c!='\n') return false; size+=1; return true; }

bool Tstdb::Getlogline (  ifstream &  in, TAction &  action, bool &  commit, int &  size, bool &  final )  [private]

Parser Get log file lines. Getlogline is designed to read an entry from the LOG file and recover the action it stores. Parameters: in  The stream we are reading from action  The action returned by reference commit  Indicates end of transaction size  Returns the size of the current entry final  Indicates if it's the end Returns: True if LOG line recovery went OK Definition at line 257 of file stdb.cpp. References Getline(). Referenced by Initialize(). { // "C" check char c; in.get(c); if (in.eof()){ // End of file detection final = true; in.get(c); return true; } final = false; if(c==COMMIT){ // A Commit commit = true; // Get '\n', end of line in.get(c); if(in.eof()) return false; if(c!='\n') return false; size = 2; return true; } else{ // Not a Commit commit = false; if(c!='+') return false; return Getline(in, action, size); } }

bool Tstdb::Getstatus (  int *  LogStatus, int *  CDBStatus )

Return status. Parameters: LogStatus  Returns a pointer to status of log file CDBStatus  Returns a pointer to status of db file Returns: False if anything's wrong

void Tstdb::Initialize (  void   )

Initialize: transfers DB from file to memory. Initialize reads data from de LOG and DB file and store transactions inside a new DB in memory. Definition at line 89 of file stdb.cpp. References db, DBMemory, Getcdbline(), Tstdb::TAction::GetData(), Tstdb::TAction::GetFunction(), Tstdb::TAction::GetKey(), Getlogline(), log, OpenCDBStatus, OpenLogStatus, ReadBytes, Rollback(), and RollBack. Referenced by Tstdb(). { // To truncate the log file if it founds format errors int ReadBytesTran = 0; char dbtmp[100]; sprintf(dbtmp, "%s.tmp", db); // Checking if TMP exists, because it means something went wrong // during last Reorganize. If it exists, it renames it from TMP // to DB ifstream fdtmp(dbtmp, ios::in); if(fdtmp) rename(dbtmp,db); fdtmp.close(); // Opening DB file in read-only mode. Now we're going to transfer // DB entries saved into the file to a new DBMemory object. ifstream cdbIn(db , ios::in); if(!cdbIn){ // If DB file doesn't exist OpenCDBStatus=CDBNOFILE; } else{ // DB file do exist OpenCDBStatus=CDBOK; // Loops DB file to fill the map object // It reads lines from DB file while we don't reach the end of file. string buffer; while (!cdbIn.eof()){ bool final; TAction action; if (!Getcdbline(cdbIn, action, final)){ // Format error encountered, file corrupted OpenCDBStatus=CDBCORRUPTION; break; } if(!final){ // Introduce (key,data) into map object DBMemory.insert(TValue(action.GetKey(),action.GetData())); } } } // Let's transfer the log file into memory map ifstream logIn(log, ios::in); if (!logIn){ // LOG file doesn't exist OpenLogStatus=LogNOFILE; } else{ // LOG file do exist ReadBytes=0; // Loop LOG entries/lines to fill map object string buffer; while (!logIn.eof()){ // Read line bool commit, final; int size; TAction action; if (!Getlogline(logIn, action, commit, size, final)){ // Format error OpenLogStatus=LogCORRUPTION; break; } if(final) continue; if(commit){ // End of transaction ReadBytes+=ReadBytesTran+2; ReadBytesTran = 0; // Pop all Actions from stack while(!RollBack.empty()){ RollBack.pop(); } } else{ // Not the end of transaction ReadBytesTran+=size; // Search (key,data) into memory map TDBMemory::iterator p = DBMemory.find(action.GetKey()); // Difference between DELETE, UPDATE and INSERT and others switch(action.GetFunction()){ case DELETE: // DELETE case if (p != DBMemory.end()){ // Found // Update the rollback with update TAction action2(INSERT, action.GetKey(), p->second); RollBack.push(action2); // Erase (key,data) from map object DBMemory.erase(action.GetKey()); } else{ // Not found // Nothing to do here } break; case UPDATE: case INSERT: // Distinguish between INSERT and UPDATE if (p != DBMemory.end()){ // Found // UPDATE case // Update the rollback with update TAction action2(UPDATE, action.GetKey(), action.GetData()); RollBack.push(action2); // Update (key,data) into map object DBMemory[action.GetKey()] = action.GetData(); } else{ // Not found // INSERT case // Update the rollback with delete TAction action2(DELETE, action.GetKey(), ""); RollBack.push(action2); // Introduce (key,data) into map object DBMemory.insert(TValue(action.GetKey(),action.GetData())); } break; } } } // If EOF and rollback stack is not empty -> LOG file corrupted if (OpenLogStatus == LogCORRUPTION){ // Rollback the current transaction Rollback(); // Truncate the log file truncate(log, ReadBytes); } else OpenLogStatus=LogOK; } }

bool Tstdb::Insert (  char *  key, unsigned int  lkey, char *  data, unsigned int  ldata )

Insert a key/value pair to database. Parameters: key  The key to be inserted lkey  The size of that key data  The data to be inserted ldata  The size of data Returns: False if key exists Definition at line 425 of file stdb.cpp. References DBMemory, RedoLog, and RollBack. { string keys(key,key+lkey); string datas(data,data+ldata); // Search (key,data) into memory map TDBMemory::iterator p = DBMemory.find(keys); if (p != DBMemory.end()){ // Key found, // not possible to Insert return false; } else{ // Not found // Pushing a Delete to the RollBack stack TAction action1(DELETE, keys, ""); RollBack.push(action1); // Pushing an Insert to the RedoLog queue TAction action2(INSERT, keys, datas); RedoLog.push(action2); // Inserting (key,data) into map object DBMemory.insert(TValue(keys,datas)); return true; } }

bool Tstdb::Nextkey (  const char **  key, unsigned int *  lkey, const char **  data, unsigned int *  ldata )

Find next key in database. Parameters: key  Returns a pointer to next key lkey  Returns a pointer to size of next key data  Returns a pointer of data ldata:  returns a pointer to size of data Returns: False if anything's wrong Definition at line 754 of file stdb.cpp. References DBMemory, and index. { // Verify if not elements if (index == DBMemory.end()) return false; *lkey = index->first.length(); *key = index->first.c_str(); *ldata = index->second.length(); *data = index->second.c_str(); index++; return true; }

bool Tstdb::ParserLineDeleteOut (  string &  line, TAction &  action )  [private]

Parser line delete out. ParserLineDeleteOut is designed to read a DELETE action and generate a plain text line, formatted to fit into the LOG file. Parameters: line  The output string action  The action to be parsed Returns: True if parsing went OK Definition at line 596 of file stdb.cpp. References Tstdb::TAction::GetKey(). Referenced by Commit(). { char buffer[100]; // Output delete format defined here sprintf(buffer, "+%lu,-1:", (unsigned long) action.GetKey().size()); char *d; d=buffer+strlen(buffer); memmove(d,action.GetKey().c_str(), action.GetKey().size()); d+=action.GetKey().size(); *(d++)='-'; *(d++)='>'; *(d++)='\n'; string linermp(buffer,d); line = linermp; return true; }

bool Tstdb::ParserLineOut (  string &  line, TAction &  action )  [private]

Parser Line out. ParserLineOut is designed to read a INSERT or UPDATE action an generate a plain text line, formatted to fit into the LOG file. Parameters: line  The output string action  The action to be parsed Returns: True if parsing went OK Definition at line 568 of file stdb.cpp. References Tstdb::TAction::GetData(), and Tstdb::TAction::GetKey(). Referenced by Commit(), and Reorganize(). { char buffer[100]; // Output format is defined here sprintf(buffer, "+%lu,%lu:", (unsigned long)action.GetKey().size(), (unsigned long)action.GetData().size()); char *d; d=buffer+strlen(buffer); memmove(d,action.GetKey().c_str(), action.GetKey().size()); d+=action.GetKey().size(); *(d++)='-'; *(d++)='>'; memmove(d,action.GetData().c_str(), action.GetData().size()); d+=action.GetData().size(); *(d++)='\n'; string linetmp(buffer,d); line = linetmp; return true; }

bool Tstdb::Reorganize (   )

Reorganize: transfers logged transactions to DB file. Reorganize writes a new cdb incorporating all the logged changes, delete the log and reopen the new cdb. Returns: True if everything ok. Definition at line 659 of file stdb.cpp. References db, DBMemory, log, ParserLineOut(), and Rollback(). Referenced by ReorganizeNecessary(). { // Rollback the current transaction if not finished Rollback(); // Rename the actual DB to DB.tmp char dbtmp[100]; sprintf(dbtmp, "%s.tmp", db); rename(db, dbtmp); // Checking if existing DB ofstream cdbOut(db); if (!cdbOut){ return false; } // Iterator at the beginning of // the memory map TDBMemory::iterator DBIter = DBMemory.begin(); // Loop: rebuilding the DB file while (DBIter != DBMemory.end()){ TAction action(INSERT,DBIter->first, DBIter->second); // Parser line out string buffer; ParserLineOut(buffer, action); cdbOut << buffer; DBIter++; } // Closing DB file cdbOut << endl; // Erasing the LOG file unlink(log); // Erasing the TMP file unlink(dbtmp); return true; }

bool Tstdb::ReorganizeNecessary (   )  [private]

Reorganize: check if is necessary to remake the cdb file. Depending on the value of MaxLogSize i MaxTime, Commit function will call to Reorganize automatically, to update and rebuild the DB file. Definition at line 705 of file stdb.cpp. References db, log, MaxLogSize, MaxTime, and Reorganize(). Referenced by Commit(). { struct stat file_cdb_stats; struct stat file_log_stats; if (stat(log, &file_log_stats)!=-1){ // LOG exists // Verify max size if (file_log_stats.st_size > MaxLogSize) return Reorganize(); // Verify max time cdb to log file if (stat(db, &file_cdb_stats)!=-1){ if(difftime(file_log_stats.st_mtime, file_cdb_stats.st_mtime) > MaxTime) return Reorganize(); } } return true; }

bool Tstdb::Rollback (  void   )

RollBack transaction. It's like an Undo function. Returns: False if anything's wrong Definition at line 621 of file stdb.cpp. References DBMemory, Tstdb::TAction::GetData(), Tstdb::TAction::GetFunction(), Tstdb::TAction::GetKey(), RedoLog, and RollBack. Referenced by Initialize(), and Reorganize(). { // Redo the last transaction, using the RollBack stack // Transfer the RedoLog queue to LOG file while(!RollBack.empty()){ TAction &action = RollBack.top(); switch(action.GetFunction()){ case INSERT: // Inserting (key,data) into map object DBMemory.insert(TValue(action.GetKey(),action.GetData())); break; case UPDATE: // Updating (key,data) into map object DBMemory[action.GetKey()] = action.GetData(); break; case DELETE: // Erasing (key,data) from map object DBMemory.erase(action.GetKey()); break; } RollBack.pop(); } // Empty the RedoLog queue // Pop all Actions from queue while(!RedoLog.empty()) RedoLog.pop(); return true; }

bool Tstdb::Update (  char *  key, unsigned int  lkey, char *  data, unsigned int  ldata )

Update a key/value pair to database. Parameters: key  The key to be updated lkey  The size of updated key data:  The data to be updated ldata:  The size of the updated data Returns: False if not exists Definition at line 393 of file stdb.cpp. References DBMemory, RedoLog, and RollBack. { string keys(key,key+lkey); string datas(data,data+ldata); // Search (key,data) into memory map TDBMemory::iterator p = DBMemory.find(keys); if (p != DBMemory.end()){ // Found key // Update the rollback with update TAction action1(UPDATE, keys, p->second); RollBack.push(action1); // Update the redolog with update TAction action2(UPDATE, keys, datas); RedoLog.push(action2); // Update (key,data) into map object DBMemory[keys] = datas; return true; } else{ // Key not found // Nothing to do return false; } }

---

Member Data Documentation

char* Tstdb::db [private]

Filenames for the database file and the log file. This "db" and "log" char arrays will contain the names of the database and log files, respectively. Definition at line 102 of file stdb.h. Referenced by Initialize(), Reorganize(), ReorganizeNecessary(), and Tstdb().

TDBMemory Tstdb::DBMemory [private]

Declaration of DBMemory map object. This is the DBMemory object containg the database in memory. Definition at line 135 of file stdb.h. Referenced by Delete(), Fetch(), Firstkey(), Initialize(), Insert(), Nextkey(), Reorganize(), Rollback(), and Update().

TDBMemory::iterator Tstdb::index [private]

The index iterator. An iterator is like a pointer designed for STL containers. The index iterator is designed to sequence objects stored into the DBMemory map. Definition at line 142 of file stdb.h. Referenced by Firstkey(), and Nextkey().

char * Tstdb::log [private]

Filenames for the database file and the log file. This "db" and "log" char arrays will contain the names of the database and log files, respectively. Definition at line 102 of file stdb.h. Referenced by Commit(), Initialize(), Reorganize(), ReorganizeNecessary(), and Tstdb().

int Tstdb::MaxLogSize [private]

Maximum longitude of the log file to rebuild the database file. The database should remake itself when the log file achieves this size, expressed in bytes. Definition at line 109 of file stdb.h. Referenced by ReorganizeNecessary(), and Tstdb().

int Tstdb::MaxTime [private]

Maximum time between cdb and log in days. This integer variable stores the time between de database file and the log file. Definition at line 116 of file stdb.h. Referenced by ReorganizeNecessary(), and Tstdb().

enum { ... } Tstdb::OpenCDBStatus [private]

Database file possible status. OpenCDBStatus reports the DB file status: OK, CORRUPTED OR NOT EXISTING. Referenced by Initialize().

enum { ... } Tstdb::OpenLogStatus [private]

Log file possible status. OpenLogStatus indicates the LOG file status, which could be correct corrupted or not existing, resp. Referenced by Initialize().

int Tstdb::ReadBytes [private]

To truncate the log file if format error. ReadBytes stores the current transaction lenght, in order to truncate the LOG file in case of data corruption. Definition at line 163 of file stdb.h. Referenced by Initialize().

queue<TAction, list<TAction> > Tstdb::RedoLog [private]

The RedoLog queue. This queue is designed to store actions done to the database in order to store them into the LOG file. Definition at line 250 of file stdb.h. Referenced by Commit(), Delete(), Insert(), Rollback(), and Update().

stack<TAction, vector<TAction> > Tstdb::RollBack [private]

The RollBack stack. This stack stores inverse actions in order to undo changes done to the database. Definition at line 243 of file stdb.h. Referenced by Commit(), Delete(), Initialize(), Insert(), Rollback(), and Update().

---