/home/alex/STDB/stdb/src/stdb/stdb.cpp

/***************************************************************************
                          stdb.cpp  -  Simple Tansactional Data Base
                             -------------------
    begin                :  16/mar/2004
    copyright            :  (C) 2004 by Andreu Moreno
    email                :  amoreno@euss.es
                            alexbc@auna.com
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Lesser General Public
 *  License as published by the Free Software Foundation; either
 *  version 2.1 of the License, or (at your option) any later version.

 *  This library is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  Lesser General Public License for more details.

 *  You should have received a copy of the GNU Lesser General Public
 *  License along with this library; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
 *                                                                         *
 ***************************************************************************/

/*
 *
 * Features:
 *
 *  - Database (stored into DB file)
 *
 *  - Transaction support (transactions logged into LOG file)
 *
 *  - Operation:
 *
 *      -> Initially, database is created and contained in memory (faster)
 *      -> DB file: (cdb formatted) Contains a read only database
 *      -> LOG file:(rdbm log format) Adds the write feature to DB file
 *      -> Periodically the DB file is updated using the LOG file (Reorganize)
 * 
 * $Author: amoreno $
 * $Revision: 1.4 $
 * $Log: stdb.cpp,v $
 * Revision 1.4  2005/05/10 10:59:52  amoreno
 * Added comments, doxygen formatted and bug cleaning
 *
 * Revision 1.3  2004/06/14 16:25:34  amoreno
 * Remove cdb dependece
 *
 * Revision 1.2  2004/03/31 14:53:33  amoreno
 * stdb.cpp cleaning up
 *
 * Revision 1.1.1.1  2004/03/23 10:13:10  amoreno
 * Initial import.
 *
 *
 */

#include <stdb.h>


//  Constructor  /

Tstdb::Tstdb(const char *TCDBName, const char *TCDBLogName, const int ParMaxLogSize, const int ParMaxTime){
    
    //  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();
}


//Initialize

void Tstdb::Initialize(void){
    
    //  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;
    }   
}


//Get a database file line

bool Tstdb::Getcdbline(ifstream &in, TAction &action, bool &final){

    //  "+" 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);
}


//  Get a log file line

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

    //  "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);
    }
}


//  Get a generic line from the DB or the LOG file

bool Tstdb::Getline(ifstream &in, TAction &action, int &size){
    
    //  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;
}


//  Update a key/value pair to database   //

bool Tstdb::Update(char *key,unsigned int lkey, char *data, unsigned int ldata){
    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;
    }
}           


//  Insert a key/value pair to  database

bool Tstdb::Insert(char *key,unsigned int lkey, char *data, unsigned int ldata){
    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;
    }
}           


//  Fetch the value for a given key from the database /

bool Tstdb::Fetch(char *key,unsigned int lkey, const char **data, unsigned int *ldata){
    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;
    }
}       


//  Delete key/value pair from database //

bool Tstdb::Delete(char *key,unsigned int lkey){
    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;
    }
}       


//  Validate the transaction //

bool Tstdb::Commit(void){

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


//  Parser line Out  /

bool Tstdb::ParserLineOut(string &line, TAction &action){
    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;
}
    
    
//  Parser line Delete Out /

bool Tstdb::ParserLineDeleteOut(string &line, TAction &action){
    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;
}


//  RollBack transaction /

bool Tstdb::Rollback(void){
    //  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;
}           


//  Reorganize /    

bool Tstdb::Reorganize(){
    //  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;
}


//  Check if Reorganize is necessary    /

bool Tstdb::ReorganizeNecessary(){

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


//  Firstkey //

bool Tstdb::Firstkey(const char **key,unsigned int *lkey, const char **data, unsigned int *ldata){
    //  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;
}


//  Nextkey  /

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

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

//
//void Tstdb::Finalize(){
//  delete db;
//  delete log;
//}


//  Destructor /

Tstdb::~Tstdb(){
}

---