src/objectlayer/TableTemplate.cpp

#include "TableTemplate.hpp"
#include "TableFactory.hpp"
#include "ObjectLayerTables.hpp"
#include "ObjectLayerException.hpp"
#include "DBException.hpp"
#include "NameMaper.hpp"
#include "Util.hpp"
#include "Log.hpp"
#include <log4cxx/logger.h>
#include <exception>


///Default constructor
template <class R>
TableTemplate<R>::TableTemplate(){
  this->init();
};


template <class R>
TableTemplate<R>::~TableTemplate(){
  for(rowIterator = rows.begin(); 
      rowIterator != rows.end(); 
      ++rowIterator )   {
    delete *rowIterator;
  }
        delete sql;
        /*for(tivIterator = tiv.begin(); 
          tivIterator != tiv.end(); 
          ++tivIterator )       {
          delete *tivIterator;
          }*/
        
};

template <class R>
TableTemplate<R>::TableTemplate(DBManagement* dbmanager){
  this->dbmanager = dbmanager;
  this->init();
};

template <class R>
void TableTemplate<R>::setDBManager(DBManagement* dbmanager){
  this->dbmanager = dbmanager;
}

template <class R>
void TableTemplate<R>::addRow(RowInterface* aRow) {
        this->rows.push_back((R*)aRow);
}


template <class R>
void TableTemplate<R>::addRow(R* aRow) {
  this->rows.push_back(aRow);
}

template <class R>
string* TableTemplate<R>::getTableName(void) {
  return this->tableName;
}

template <class R>
Dictionary* TableTemplate<R>::getSchema() {
  cout<<"RETURNNING SCHEMA..."<<endl;
  return this->schema;
}


template <class R>
void TableTemplate<R>::init() {
  cout<<"initilizing......"<<endl;
  static Log l("TableTemplate");
  TableTemplate::logger = l.getLogger();
        schema = this->schemaNconstraints.schemaNconstraints.getSchema();
        constraints = this->schemaNconstraints.schemaNconstraints.getConstraints();
        primaryKeys = this->schemaNconstraints.schemaNconstraints.getPrimaryKeys();
        uniqueKeys = this->schemaNconstraints.schemaNconstraints.getUniqueKeys();
        notNullKeys = this->schemaNconstraints.schemaNconstraints.getNotNullKeys();
        refrences = this->schemaNconstraints.schemaNconstraints.getReferences();
        multiRefrences = this->schemaNconstraints.schemaNconstraints.getMultiReferences();
        tableName = this->schemaNconstraints.schemaNconstraints.getTableName();
        //cout<<"table name is set now "<<*tableName<<endl;
        //LOG4CXX_DEBUG(TableTemplate::logger, "table name is set now");
        schemaOrder = this->schemaNconstraints.schemaNconstraints.getSchemaOrder();
        util.setSchema(schema);
        sql = new SQL(&util);
        cout<<"primary keys "<<endl;
        primaryKeysReal = util.getPrimaryKeys(schemaOrder->begin(), schemaOrder->end(), multiRefrences->begin(), multiRefrences->end());
        cout<<"DONE initilizing......"<<endl;
};


template <class R>
Dictionary TableTemplate<R>::getSatisfiedRefrences(ResultSet* rs, int rowIndex) {
  Dictionary satisfiedRefrences;
  for(Dictionary_iter i = multiRefrences->begin(); i != multiRefrences->end(); ++i) {
    if( (string) rs->getElement(rowIndex, rs->getColIndex(i->first)) == 
        (string) rs->getElement(rowIndex, rs->getColIndex(i->second + "." + i->first)) ) {
      //cout<<"Satisfied relation "<<util.getTokenAt(i->second,0)<<" is equal to "<<i->first<<" value is "<<(string) rs->getElement(rowIndex, rs->getColIndex(i->first))<<endl;
      LOG4CXX_DEBUG(TableTemplate::logger, "Satisfied relation "+util.getTokenAt(i->second,0) + " is equal to " + i->first + " value is " + (string) rs->getElement(rowIndex, rs->getColIndex(i->first)) );
                        satisfiedRefrences.insert(Entry(util.getTokenAt(i->second,0),i->first));
    }
    
  }
  return(satisfiedRefrences);
}

template <class R>
void TableTemplate<R>::convertIntoRow(ResultSet* rs, int rowIndex, R* tmpRow) {
  Dictionary satisfiedRefrences = this->getSatisfiedRefrences(rs,rowIndex);
  for(int colIndex = 0; colIndex < rs->getNoOfCols(); colIndex++) {
    string name = rs->getColName(colIndex);
                if( name.length() == 63 ) {
                  for(Dictionary_iter schemaIterator = schema->begin(); 
                      schemaIterator != schema->end(); schemaIterator++) {
                    string nameFromSchema = schemaIterator->first;
                    if(nameFromSchema.substr(0,63) == name) {
                      name = nameFromSchema;
                      break;
                                }
                  }
                }
                //if(!toSetCol(name,satisfiedRefrences)) {
                //cout<<"toSetCol "<<endl;
                if(!util.toSetCol(name, satisfiedRefrences.begin(), satisfiedRefrences.end())) {
                        //cout<<"toSetCol returned false for "<<name<<endl;
                  continue;
                } 
                cout<<"trying to fetch value from ResultSet"<<endl;
                string value = rs->getElement(rowIndex,colIndex);
                if(value.length() == 0) { 
                  continue;
                }
                cout<<"value is "<<value<<endl;
                string dataType = util.getDataType(name);
                cout<<"dataType "<<dataType;
                util.setValue(tmpRow, name, dataType, value);
                cout<<"after setvalue"<<endl;
  }
  //cout<<"returnning tmpRow"<<endl;
}

template <class R>
string TableTemplate<R>::makeSelectQuery(string userGivenWhereClause="") {
  //cout<<"inside ::makeSelectQuery"<<endl;
  string sqlQuery = sql->makeSelectClause(schema->begin(), schema->end()) + 
    " FROM " +
    sql->makeTableClause(schemaOrder->begin(), schemaOrder->end());
  string whereClause = this->makeWhereClause(userGivenWhereClause);
  if( whereClause.length() > 0 ) {
    sqlQuery = sqlQuery + "\nWHERE\n" + whereClause;
        }
  //cout<<"Query is "<<endl<<sqlQuery<<endl;
  LOG4CXX_INFO(logger,"Query is " + sqlQuery);
  return (sqlQuery);
}


template <class R>
string TableTemplate<R>::makeWhereClause(string userGivenWhereClause="") {
        //cout<<"inside ::makeWhereClause"<<endl;
  string whereClause = sql->makeRefClause(refrences->begin(), refrences->end()) ;
  string whereMultiRefClause = sql->makeMultiRefClause(multiRefrences->begin(), multiRefrences->end()) ;
  int whereClauseLen = whereClause.length();
  if(whereClauseLen > 0) {
    if(whereMultiRefClause.length() > 0) {
      whereClause += " AND " + whereMultiRefClause;
    }
        }else if(whereMultiRefClause.length() > 0) {
    whereClause = whereMultiRefClause;
  }
  if( whereClauseLen == 0 ) {
    return(userGivenWhereClause);
  }
  if( userGivenWhereClause.length() > 0 ) {
                whereClause += " AND " + userGivenWhereClause ;
  }
  return(whereClause);
}

template <class R>
ResultSet * TableTemplate<R>::doSelect(string query="", string whereClause="") {
        //return query.length() == 0 ? 
        //      dbmanager->executeQueryWithResults(this->makeSelectQuery(whereClause)) : 
        //      dbmanager->executeQueryWithResults(query) ;
  string tempQuery = "";
  if( query.length() == 0 ) {
    tempQuery = this->makeSelectQuery(whereClause);
        } else {
    tempQuery = query;
  }
  //LOG4CXX_INFO(TableTemplate::logger,"Query is " + tempQuery);
  //cout<<"calling dbmanager->executeQueryWithResults(tempQuery)"<<endl;
  return dbmanager->executeQueryWithResults(tempQuery) ;

}

template <class R>
void TableTemplate<R>::reSetColNamesInRS(ResultSet * rs) {
  NameMaper nm;
        for(int i = 0; i < rs->getNoOfCols(); ++i) {
          string colName = rs->getColName(i);
          bool found = false;
          //for(NmIterator ni = nm.NameMap.begin(); ni != nm.NameMap.end(); ++ni) {
          for(Dictionary_iter ni = nm.NameMap.begin(); ni != nm.NameMap.end(); ++ni) {
            if(ni->second == colName) {
                                rs->setColName(i, ni->first);
                                found = true;
                                break;
            }
          }
                if(!found) {
                  throw ObjectLayerException("Name Mater could not found key "+colName);
                }
        }
}

template <class R>
//vector<R*>::iterator& TableTemplate<R>::select(string whereClause=""){
vector<R*>& TableTemplate<R>::select(string whereClause=""){
  //vector<RowInterface*>& TableTemplate<R>::select(string whereClause=""){
//TableInterface TableTemplate<R>::select(string whereClause=""){
  bool exceptionOccured = false;
  string exceptionMessage = "\n";
  
  //ResultSet * rs = this->doSelect("",whereClause);
  ResultSet * rs;
  try {
    rs = this->doSelect("",whereClause);
    this->reSetColNamesInRS(rs);
    
    cout<<"NOOFROWS iS "<<rs->getNoOfRows()<<endl<<endl;
    LOG4CXX_DEBUG(TableTemplate::logger,"noOfRows is " + rs->getNoOfRows());
    for(int rowIndex = 0; rowIndex < rs->getNoOfRows(); rowIndex++) {
      //cout << "\n\nChecking PK" << endl;
      bool pKEqual = false;
      for(rowIterator = rows.begin(); rowIterator != rows.end(); ++rowIterator ) {
      //cout << "\n\nChecking Next Row..." << endl;
        R* aRow = (R*)*rowIterator;
        pKEqual = false;
        for(Keys_iter i = primaryKeys->begin(); i!= primaryKeys->end(); ++i) {
         
          string dataType = util.getDataType(*i) ;
          if (util.isSet(aRow, *i ,dataType) ) {
            if( (string) rs->getElement(rowIndex, rs->getColIndex(*i)) != 
               util.getStrValue(aRow, *i , dataType) ) {
                pKEqual = false;
                break;
          
            } else {
               pKEqual = true;
           }
         }
        }
        if(pKEqual) {
          //cout<<"ITSEQUAL "<<endl;
          LOG4CXX_DEBUG(TableTemplate::logger,"ITSEQUAL");
          this->convertIntoRow(rs,rowIndex,aRow);
          break;
        }
      }
      if(!pKEqual) {
        //cout<<"INSERT BEACUSE it is UNEQUAL"<<endl;
        LOG4CXX_DEBUG(TableTemplate::logger,"INSERT BEACUSE it is UNEQUAL");
        R* tempRow = new R();
        cout<<"calling convert into rows"<<endl;
        this->convertIntoRow(rs, rowIndex,tempRow);
        rows.push_back(tempRow);
        cout<<"line11"<<endl;
      }
    }
    //rowIterator = rows.begin();
  } catch (ObjectLayerException &e) {
    exceptionOccured = true;
    exceptionMessage = e.report();
    delete rs;
  } catch (DBException &e) {
    exceptionOccured = true;
    exceptionMessage = e.report();
  } catch (exception &e) {
    exceptionOccured = true;
    exceptionMessage = e.what();
    delete rs;
  }
  
  //return this->rowIterator;
  if(exceptionOccured) {
    LOG4CXX_ERROR(TableTemplate::logger,exceptionMessage);
    throw ObjectLayerException(exceptionMessage);
  }
  
  return rows;
  //return *this;
}

template <class R>
vector<string> TableTemplate<R>::makeInsertQuery(R* aRow) {
  vector<string> toReturn;
        for(Keys_iter i = schemaOrder->begin();
            i != schemaOrder->end(); i++) {
          if( util.isInMultiRef(*i, multiRefrences->begin(), multiRefrences->end()) ) {
            for(Dictionary_iter m = multiRefrences->begin(); 
                m != multiRefrences->end(); 
                                m++) {
              if(*i == util.getTokenAt(m->second,0) ) {
                cout<<"Multi FOUND" <<endl;
                toReturn.push_back( sql->makeInsertQuery(aRow,*i,m->first, schema->begin(), schema->end()) );
              }
            }
          } else {
                        toReturn.push_back( sql->makeInsertQuery(aRow, *i, "", schema->begin(), schema->end()) );
          }
        }
        return(toReturn);
}


/*
  template <class R>
  void TableTemplate<R>::insert() {
  for(rowIterator = rows.begin(); rowIterator != rows.end(); rowIterator++ ) {
  R* aRow = (R*)*rowIterator;
  makeInsertQuery(aRow);
  }
}
*/

template <class R>
void TableTemplate<R>::insert() {
  bool exceptionOccured = false;
  string exceptionMessage = "\n";
        int i = -1;
        for(rowIterator = rows.begin(); rowIterator != rows.end(); ++rowIterator ) {
          ++i;
          R* aRow = (R*)*rowIterator;
          try{
            //cout<<endl<<"inserting ROW no "<<i<<endl;
                        LOG4CXX_DEBUG(TableTemplate::logger,"inserting ROW no ");
                        LOG4CXX_DEBUG(TableTemplate::logger,i);
                        this->doSmartInsert(aRow);
                        //cout<<"out of smart insert"<<endl;
                        //doSimpleInsert(aRow);
                } catch (ObjectLayerException &e) {
            exceptionOccured = true;
            exceptionMessage += "At row "+util.itoa(i)+": "+ e.report() + " \n";
          } catch (DBException &e) {
                        exceptionOccured = true;
                        exceptionMessage += "At row "+util.itoa(i)+": "+ e.report() + " \n";
          } catch (exception &e) {
            exceptionOccured = true;
            exceptionMessage += "At row "+util.itoa(i)+": "+ e.what() + " \n";
          }
          
        }
        //cout<<"OUT of FOR Loop"<<endl;
        if(exceptionOccured) {
          LOG4CXX_ERROR(TableTemplate::logger,exceptionMessage);
          throw ObjectLayerException(exceptionMessage);
        }
}


template <class R>
void TableTemplate<R>::doSimpleInsert(R* aRow) {
  //cout<<"inside doSimpleInsert"<<endl;
  LOG4CXX_DEBUG(TableTemplate::logger,"inside doSimpleInsert");
  
  //if(!isNotNullKeySet(aRow)) {
  this->fixPKWithSeq(aRow);
  //this->setTimeInRow(aRow);
  //this->setPersonInRow(aRow);
  if(!util.isKeySet(aRow, notNullKeys->begin(), notNullKeys->end()) ) {
    string message = "Coloumn name "+*util.getNullKey(aRow, notNullKeys->begin(), notNullKeys->end())+" is NULL";
    LOG4CXX_ERROR(TableTemplate::logger,message);
    throw ObjectLayerException(message);
    
  }
  //this->fixPKWithSeq(aRow);
  //if(isPrimaryKeySet(aRow)) {
  //if( util.isKeySet(aRow, primaryKeys->begin(), primaryKeys->end()) ) {
  if( util.isKeySet(aRow, primaryKeysReal.begin(), primaryKeysReal.end()) ) {
    vector<string> strQuery = this->makeInsertQuery(aRow);
    typedef vector<string>::iterator QueryIter;
                for(QueryIter qi = strQuery.begin(); qi != strQuery.end(); ++qi ) {
                  //cout<<"Query to execute is "<<endl<<*qi<<endl;
                  
                  LOG4CXX_INFO(TableTemplate::logger,"Query is "+*qi);
                  int returnCode = dbmanager->executeQuery(*qi);
                  if(returnCode != 0) {
                    throw ObjectLayerException("Query: "+*qi+" could not be executed");
                  }
                }
  } else {
    throw ObjectLayerException("Sequencers falied to set Primary key ");
  }
}


template <class R>
void TableTemplate<R>::delRows() {
  cout<<"ERASING rows"<<endl;
  rows.clear();
}


template <class R>
void TableTemplate<R>::insertSingle(R* aRow, string name, string fkey) {
  name += "row";
  cout<<"name is "<<name<<" fkey is "<<fkey<<endl;
  RowInterface* subRow = (RowInterface*)aRow->getConstituentRow(name,fkey);
        cout<<"RowInterface* subRow = (RowInterface*)aRow->getConstituentRow(name,fkey) "<<endl;          
TableFactory tf;
  //cout<<"calling tf.getTableObject"<<endl;
  TableInterface* ti = tf.getTableObject(name);
  ti->setDBManager(dbmanager);
  //cout<<"Done calling tf.getTableObject"<<endl;
  ti->addRow(subRow);
  ti->insert();
  ti->delRows();
  delete ti;
  
  util.equatePKWithRef(aRow, refrences->begin(), refrences->end() );
  util.equatePKWithMultiRef(aRow, multiRefrences->begin(), multiRefrences->end() );
  
}


template <class R>
void TableTemplate<R>::insertMulti(R* aRow, string name) {
  bool exceptionOccured = false;
  string exceptionMessage = "\n";
  
        for(Dictionary_iter m = multiRefrences->begin(); m != multiRefrences->end(); ++m) {
          try {
            //cout<<"checking name "<<name<<" with util.getTokenAt(m->second,0) "<<util.getTokenAt(m->second,0)<<endl;
            if(name == util.getTokenAt(m->second,0) ) {
              this->insertSingle(aRow, name, m->first);
            }
          } catch (ObjectLayerException &e) {
                        exceptionOccured = true;
                        exceptionMessage += "At row "+name+": "+ e.report() + " \n";
          } catch (DBException &e) {
            exceptionOccured = true;
            exceptionMessage += "At row "+name+": "+ e.report() + " \n";
          } catch (exception &e) {
                        exceptionOccured = true;
                        exceptionMessage += "At row "+name+": "+ e.what() + " \n";
          }
          
        }
        if(exceptionOccured) {
                throw ObjectLayerException(exceptionMessage);
        }
}

/*
template <class R>
void TableTemplate<R>::doSmartInsert(R* aRow) {
        //cout<<"inside doSmartInsert for TableTemplate"<<endl;
        LOG4CXX_DEBUG(TableTemplate::logger,"inside doSmartInsert for TableTemplate");
        bool exceptionOccured = false;
        string exceptionMessage = "\n";

        for(Keys_iter i = schemaOrder->begin(); i != schemaOrder->end(); ++i) {
                try{
                        if( util.isInMultiRef(*i, multiRefrences->begin(), multiRefrences->end()) ) {
                                this->insertMulti(aRow,*i);
                        } else {
                                this->insertSingle(aRow, *i,"");
                        }       
                } catch (ObjectLayerException &e) {
                        exceptionOccured = true;
                        exceptionMessage += "At row "+*i+": "+ e.report() + " \n";
                } catch (DBException &e) {
                        exceptionOccured = true;
                        exceptionMessage += "At row "+*i+": "+ e.report() + " \n";
                } catch (exception &e) {
                        exceptionOccured = true;
                        exceptionMessage += "At row "+*i+": "+ e.what() + " \n";
                }


        }
        if(exceptionOccured) {
                throw ObjectLayerException(exceptionMessage);
        }
}
*/

template <class R>
void TableTemplate<R>::update(){
          cout << "Hello I am in Update" << endl;
}

template <class R>
int TableTemplate<R>::getSeqValue(string tableName, string colName) {
        ResultSet* rs = this->doSelect(sql->makeSeqQuery(tableName,colName),"");
        if(rs->getNoOfRows() == 0) {
                delete rs;
                return 0;
        }
        int intValue  = atoi(rs->getElement(0,0).c_str());
        delete rs;
        return ++intValue;
        
}

template <class R>
void TableTemplate<R>::fixPKWithSeq(R* aRow) {
        for(Keys_iter i = primaryKeysReal.begin(); i != primaryKeysReal.end(); ++i) {
                string dataType = util.getDataType(*i);
                if( util.isSet(aRow, *i, dataType) ) {
                        continue;
                }
                if(dataType != "INTEGER") {
                        //cout<<"Sequencer for non int type is invalid"<<endl;
                        LOG4CXX_ERROR(TableTemplate::logger,"Sequencer for non int type is invalid");
                        continue;
                }
                int value = this->getSeqValue(util.getTokenAt(*i, 0), util.getTokenAt(*i, 1));  
                cout<<"Setting sequencer value of "<<*i<<" "<<value<<endl;
                //LOG4CXX_DEBUG(TableTemplate::logger,"Setting sequencer value of " + *i + " " + value);
                aRow->setValue(*i,&value);
        }
}

template <class R>
void TableTemplate<R>::setTimeInRow(R* aRow) {
        string tableName = this->util.getTokenAt(schema->begin()->first,0);
        long value = this->util.getTime();
        //float value = this->util.getTime();
        //cout<<"setting "<<tableName<<".created_at to "<<value<<endl;
        aRow->setValue(tableName+".created_at",&value);
        aRow->setValue(tableName+".modified_at",&value);
}

template <class R>
void TableTemplate<R>::setPersonInRow(R* aRow) {
        string tableName = this->util.getTokenAt(schema->begin()->first,0);
        int value = 1;
        aRow->setValue(tableName+".created_by",&value);
        aRow->setValue(tableName+".modified_by",&value);
}

template TableTemplate<T_Schema_Revisionrow>;
template TableTemplate<T_Personrow>;
template TableTemplate<T_Physics_Grouprow>;
template TableTemplate<T_Collection_Typerow>;
template TableTemplate<T_App_Familyrow>;
template TableTemplate<T_Applicationrow>;
template TableTemplate<T_App_Configrow>;
template TableTemplate<T_Desc_Triggerrow>;
template TableTemplate<T_Desc_Mcrow>;
template TableTemplate<T_Desc_Primaryrow>;
template TableTemplate<T_Data_Tierrow>;
template TableTemplate<T_Primary_Datasetrow>;
template TableTemplate<T_Processing_Pathrow>;
template TableTemplate<T_Processed_Datasetrow>;
template TableTemplate<T_Event_Collectionrow>;
template TableTemplate<T_Analysis_Datasetrow>;
template TableTemplate<T_Anads_Datarow>;
template TableTemplate<T_Parentage_Typerow>;
template TableTemplate<T_Evcoll_Parentagerow>;
template TableTemplate<T_Block_Statusrow>;
template TableTemplate<T_Blockrow>;
template TableTemplate<T_File_Statusrow>;
template TableTemplate<T_File_Typerow>;
template TableTemplate<T_Filerow>;
template TableTemplate<T_Evcoll_Filerow>;
template TableTemplate<T_Validation_Statusrow>;
template TableTemplate<T_Dataset_Statusrow>;
template TableTemplate<T_Evcoll_Statusrow>;
template TableTemplate<T_Run_Qualityrow>;
template TableTemplate<T_Info_Anadsrow>;
template TableTemplate<T_Info_Evcollrow>;
template TableTemplate<T_Runrow>;
template TableTemplate<T_Evcoll_Runrow>;
template TableTemplate<Insertappsmultirow>;
template TableTemplate<Personmultirow>;
template TableTemplate<Physicsgroupmultirow>;
template TableTemplate<Evcollviewmultirow>;
template TableTemplate<Fileviewmultirow>;
template TableTemplate<Primarydatasetmultirow>;
template TableTemplate<Processingpathmultirow>;
template TableTemplate<Analysisdatasetmultirow>;
template TableTemplate<Datasetprovenenceevchildmultirow>;
template TableTemplate<Datasetprovenenceevparentmultirow>;
template TableTemplate<Crabevcollviewmultirow>;


Revision:	1.1
Committed:	Mon Oct 31 22:10:35 2005 UTC (19 years, 6 months ago) by afaq
Branch:	MAIN
Branch point for:	v00
Log Message:	Initial revision
#	User	Rev	Content
1	afaq	1.1	#include "TableTemplate.hpp"
2			#include "TableFactory.hpp"
3			#include "ObjectLayerTables.hpp"
4			#include "ObjectLayerException.hpp"
5			#include "DBException.hpp"
6			#include "NameMaper.hpp"
7			#include "Util.hpp"
8			#include "Log.hpp"
9			#include <log4cxx/logger.h>
10			#include <exception>
11
12
13			///Default constructor
14			template <class R>
15			TableTemplate<R>::TableTemplate(){
16			this->init();
17			};
18
19
20			template <class R>
21			TableTemplate<R>::~TableTemplate(){
22			for(rowIterator = rows.begin();
23			rowIterator != rows.end();
24			++rowIterator ) {
25			delete *rowIterator;
26			}
27			delete sql;
28			/*for(tivIterator = tiv.begin();
29			tivIterator != tiv.end();
30			++tivIterator ) {
31			delete *tivIterator;
32			}*/
33
34			};
35
36			template <class R>
37			TableTemplate<R>::TableTemplate(DBManagement* dbmanager){
38			this->dbmanager = dbmanager;
39			this->init();
40			};
41
42			template <class R>
43			void TableTemplate<R>::setDBManager(DBManagement* dbmanager){
44			this->dbmanager = dbmanager;
45			}
46
47			template <class R>
48			void TableTemplate<R>::addRow(RowInterface* aRow) {
49			this->rows.push_back((R*)aRow);
50			}
51
52
53			template <class R>
54			void TableTemplate<R>::addRow(R* aRow) {
55			this->rows.push_back(aRow);
56			}
57
58			template <class R>
59			string* TableTemplate<R>::getTableName(void) {
60			return this->tableName;
61			}
62
63			template <class R>
64			Dictionary* TableTemplate<R>::getSchema() {
65			cout<<"RETURNNING SCHEMA..."<<endl;
66			return this->schema;
67			}
68
69
70
71			template <class R>
72			void TableTemplate<R>::init() {
73			cout<<"initilizing......"<<endl;
74			static Log l("TableTemplate");
75			TableTemplate::logger = l.getLogger();
76			schema = this->schemaNconstraints.schemaNconstraints.getSchema();
77			constraints = this->schemaNconstraints.schemaNconstraints.getConstraints();
78			primaryKeys = this->schemaNconstraints.schemaNconstraints.getPrimaryKeys();
79			uniqueKeys = this->schemaNconstraints.schemaNconstraints.getUniqueKeys();
80			notNullKeys = this->schemaNconstraints.schemaNconstraints.getNotNullKeys();
81			refrences = this->schemaNconstraints.schemaNconstraints.getReferences();
82			multiRefrences = this->schemaNconstraints.schemaNconstraints.getMultiReferences();
83			tableName = this->schemaNconstraints.schemaNconstraints.getTableName();
84			//cout<<"table name is set now "<<*tableName<<endl;
85			//LOG4CXX_DEBUG(TableTemplate::logger, "table name is set now");
86			schemaOrder = this->schemaNconstraints.schemaNconstraints.getSchemaOrder();
87			util.setSchema(schema);
88			sql = new SQL(&util);
89			cout<<"primary keys "<<endl;
90			primaryKeysReal = util.getPrimaryKeys(schemaOrder->begin(), schemaOrder->end(), multiRefrences->begin(), multiRefrences->end());
91			cout<<"DONE initilizing......"<<endl;
92			};
93
94
95			template <class R>
96			Dictionary TableTemplate<R>::getSatisfiedRefrences(ResultSet* rs, int rowIndex) {
97			Dictionary satisfiedRefrences;
98			for(Dictionary_iter i = multiRefrences->begin(); i != multiRefrences->end(); ++i) {
99			if( (string) rs->getElement(rowIndex, rs->getColIndex(i->first)) ==
100			(string) rs->getElement(rowIndex, rs->getColIndex(i->second + "." + i->first)) ) {
101			//cout<<"Satisfied relation "<<util.getTokenAt(i->second,0)<<" is equal to "<<i->first<<" value is "<<(string) rs->getElement(rowIndex, rs->getColIndex(i->first))<<endl;
102			LOG4CXX_DEBUG(TableTemplate::logger, "Satisfied relation "+util.getTokenAt(i->second,0) + " is equal to " + i->first + " value is " + (string) rs->getElement(rowIndex, rs->getColIndex(i->first)) );
103			satisfiedRefrences.insert(Entry(util.getTokenAt(i->second,0),i->first));
104			}
105
106			}
107			return(satisfiedRefrences);
108			}
109
110			template <class R>
111			void TableTemplate<R>::convertIntoRow(ResultSet* rs, int rowIndex, R* tmpRow) {
112			Dictionary satisfiedRefrences = this->getSatisfiedRefrences(rs,rowIndex);
113			for(int colIndex = 0; colIndex < rs->getNoOfCols(); colIndex++) {
114			string name = rs->getColName(colIndex);
115			if( name.length() == 63 ) {
116			for(Dictionary_iter schemaIterator = schema->begin();
117			schemaIterator != schema->end(); schemaIterator++) {
118			string nameFromSchema = schemaIterator->first;
119			if(nameFromSchema.substr(0,63) == name) {
120			name = nameFromSchema;
121			break;
122			}
123			}
124			}
125			//if(!toSetCol(name,satisfiedRefrences)) {
126			//cout<<"toSetCol "<<endl;
127			if(!util.toSetCol(name, satisfiedRefrences.begin(), satisfiedRefrences.end())) {
128			//cout<<"toSetCol returned false for "<<name<<endl;
129			continue;
130			}
131			cout<<"trying to fetch value from ResultSet"<<endl;
132			string value = rs->getElement(rowIndex,colIndex);
133			if(value.length() == 0) {
134			continue;
135			}
136			cout<<"value is "<<value<<endl;
137			string dataType = util.getDataType(name);
138			cout<<"dataType "<<dataType;
139			util.setValue(tmpRow, name, dataType, value);
140			cout<<"after setvalue"<<endl;
141			}
142			//cout<<"returnning tmpRow"<<endl;
143			}
144
145			template <class R>
146			string TableTemplate<R>::makeSelectQuery(string userGivenWhereClause="") {
147			//cout<<"inside ::makeSelectQuery"<<endl;
148			string sqlQuery = sql->makeSelectClause(schema->begin(), schema->end()) +
149			" FROM " +
150			sql->makeTableClause(schemaOrder->begin(), schemaOrder->end());
151			string whereClause = this->makeWhereClause(userGivenWhereClause);
152			if( whereClause.length() > 0 ) {
153			sqlQuery = sqlQuery + "\nWHERE\n" + whereClause;
154			}
155			//cout<<"Query is "<<endl<<sqlQuery<<endl;
156			LOG4CXX_INFO(logger,"Query is " + sqlQuery);
157			return (sqlQuery);
158			}
159
160
161			template <class R>
162			string TableTemplate<R>::makeWhereClause(string userGivenWhereClause="") {
163			//cout<<"inside ::makeWhereClause"<<endl;
164			string whereClause = sql->makeRefClause(refrences->begin(), refrences->end()) ;
165			string whereMultiRefClause = sql->makeMultiRefClause(multiRefrences->begin(), multiRefrences->end()) ;
166			int whereClauseLen = whereClause.length();
167			if(whereClauseLen > 0) {
168			if(whereMultiRefClause.length() > 0) {
169			whereClause += " AND " + whereMultiRefClause;
170			}
171			}else if(whereMultiRefClause.length() > 0) {
172			whereClause = whereMultiRefClause;
173			}
174			if( whereClauseLen == 0 ) {
175			return(userGivenWhereClause);
176			}
177			if( userGivenWhereClause.length() > 0 ) {
178			whereClause += " AND " + userGivenWhereClause ;
179			}
180			return(whereClause);
181			}
182
183			template <class R>
184			ResultSet * TableTemplate<R>::doSelect(string query="", string whereClause="") {
185			//return query.length() == 0 ?
186			// dbmanager->executeQueryWithResults(this->makeSelectQuery(whereClause)) :
187			// dbmanager->executeQueryWithResults(query) ;
188			string tempQuery = "";
189			if( query.length() == 0 ) {
190			tempQuery = this->makeSelectQuery(whereClause);
191			} else {
192			tempQuery = query;
193			}
194			//LOG4CXX_INFO(TableTemplate::logger,"Query is " + tempQuery);
195			//cout<<"calling dbmanager->executeQueryWithResults(tempQuery)"<<endl;
196			return dbmanager->executeQueryWithResults(tempQuery) ;
197
198			}
199
200			template <class R>
201			void TableTemplate<R>::reSetColNamesInRS(ResultSet * rs) {
202			NameMaper nm;
203			for(int i = 0; i < rs->getNoOfCols(); ++i) {
204			string colName = rs->getColName(i);
205			bool found = false;
206			//for(NmIterator ni = nm.NameMap.begin(); ni != nm.NameMap.end(); ++ni) {
207			for(Dictionary_iter ni = nm.NameMap.begin(); ni != nm.NameMap.end(); ++ni) {
208			if(ni->second == colName) {
209			rs->setColName(i, ni->first);
210			found = true;
211			break;
212			}
213			}
214			if(!found) {
215			throw ObjectLayerException("Name Mater could not found key "+colName);
216			}
217			}
218			}
219
220			template <class R>
221			//vector<R*>::iterator& TableTemplate<R>::select(string whereClause=""){
222			vector<R*>& TableTemplate<R>::select(string whereClause=""){
223			//vector<RowInterface*>& TableTemplate<R>::select(string whereClause=""){
224			//TableInterface TableTemplate<R>::select(string whereClause=""){
225			bool exceptionOccured = false;
226			string exceptionMessage = "\n";
227
228			//ResultSet * rs = this->doSelect("",whereClause);
229			ResultSet * rs;
230			try {
231			rs = this->doSelect("",whereClause);
232			this->reSetColNamesInRS(rs);
233
234			cout<<"NOOFROWS iS "<<rs->getNoOfRows()<<endl<<endl;
235			LOG4CXX_DEBUG(TableTemplate::logger,"noOfRows is " + rs->getNoOfRows());
236			for(int rowIndex = 0; rowIndex < rs->getNoOfRows(); rowIndex++) {
237			//cout << "\n\nChecking PK" << endl;
238			bool pKEqual = false;
239			for(rowIterator = rows.begin(); rowIterator != rows.end(); ++rowIterator ) {
240			//cout << "\n\nChecking Next Row..." << endl;
241			R* aRow = (R)rowIterator;
242			pKEqual = false;
243			for(Keys_iter i = primaryKeys->begin(); i!= primaryKeys->end(); ++i) {
244
245			string dataType = util.getDataType(*i) ;
246			if (util.isSet(aRow, *i ,dataType) ) {
247			if( (string) rs->getElement(rowIndex, rs->getColIndex(*i)) !=
248			util.getStrValue(aRow, *i , dataType) ) {
249			pKEqual = false;
250			break;
251
252			} else {
253			pKEqual = true;
254			}
255			}
256			}
257			if(pKEqual) {
258			//cout<<"ITSEQUAL "<<endl;
259			LOG4CXX_DEBUG(TableTemplate::logger,"ITSEQUAL");
260			this->convertIntoRow(rs,rowIndex,aRow);
261			break;
262			}
263			}
264			if(!pKEqual) {
265			//cout<<"INSERT BEACUSE it is UNEQUAL"<<endl;
266			LOG4CXX_DEBUG(TableTemplate::logger,"INSERT BEACUSE it is UNEQUAL");
267			R* tempRow = new R();
268			cout<<"calling convert into rows"<<endl;
269			this->convertIntoRow(rs, rowIndex,tempRow);
270			rows.push_back(tempRow);
271			cout<<"line11"<<endl;
272			}
273			}
274			//rowIterator = rows.begin();
275			} catch (ObjectLayerException &e) {
276			exceptionOccured = true;
277			exceptionMessage = e.report();
278			delete rs;
279			} catch (DBException &e) {
280			exceptionOccured = true;
281			exceptionMessage = e.report();
282			} catch (exception &e) {
283			exceptionOccured = true;
284			exceptionMessage = e.what();
285			delete rs;
286			}
287
288			//return this->rowIterator;
289			if(exceptionOccured) {
290			LOG4CXX_ERROR(TableTemplate::logger,exceptionMessage);
291			throw ObjectLayerException(exceptionMessage);
292			}
293
294			return rows;
295			//return *this;
296			}
297
298			template <class R>
299			vector<string> TableTemplate<R>::makeInsertQuery(R* aRow) {
300			vector<string> toReturn;
301			for(Keys_iter i = schemaOrder->begin();
302			i != schemaOrder->end(); i++) {
303			if( util.isInMultiRef(*i, multiRefrences->begin(), multiRefrences->end()) ) {
304			for(Dictionary_iter m = multiRefrences->begin();
305			m != multiRefrences->end();
306			m++) {
307			if(*i == util.getTokenAt(m->second,0) ) {
308			cout<<"Multi FOUND" <<endl;
309			toReturn.push_back( sql->makeInsertQuery(aRow,*i,m->first, schema->begin(), schema->end()) );
310			}
311			}
312			} else {
313			toReturn.push_back( sql->makeInsertQuery(aRow, *i, "", schema->begin(), schema->end()) );
314			}
315			}
316			return(toReturn);
317			}
318
319
320
321			/*
322			template <class R>
323			void TableTemplate<R>::insert() {
324			for(rowIterator = rows.begin(); rowIterator != rows.end(); rowIterator++ ) {
325			R* aRow = (R)rowIterator;
326			makeInsertQuery(aRow);
327			}
328			}
329			*/
330
331			template <class R>
332			void TableTemplate<R>::insert() {
333			bool exceptionOccured = false;
334			string exceptionMessage = "\n";
335			int i = -1;
336			for(rowIterator = rows.begin(); rowIterator != rows.end(); ++rowIterator ) {
337			++i;
338			R* aRow = (R)rowIterator;
339			try{
340			//cout<<endl<<"inserting ROW no "<<i<<endl;
341			LOG4CXX_DEBUG(TableTemplate::logger,"inserting ROW no ");
342			LOG4CXX_DEBUG(TableTemplate::logger,i);
343			this->doSmartInsert(aRow);
344			//cout<<"out of smart insert"<<endl;
345			//doSimpleInsert(aRow);
346			} catch (ObjectLayerException &e) {
347			exceptionOccured = true;
348			exceptionMessage += "At row "+util.itoa(i)+": "+ e.report() + " \n";
349			} catch (DBException &e) {
350			exceptionOccured = true;
351			exceptionMessage += "At row "+util.itoa(i)+": "+ e.report() + " \n";
352			} catch (exception &e) {
353			exceptionOccured = true;
354			exceptionMessage += "At row "+util.itoa(i)+": "+ e.what() + " \n";
355			}
356
357			}
358			//cout<<"OUT of FOR Loop"<<endl;
359			if(exceptionOccured) {
360			LOG4CXX_ERROR(TableTemplate::logger,exceptionMessage);
361			throw ObjectLayerException(exceptionMessage);
362			}
363			}
364
365
366			template <class R>
367			void TableTemplate<R>::doSimpleInsert(R* aRow) {
368			//cout<<"inside doSimpleInsert"<<endl;
369			LOG4CXX_DEBUG(TableTemplate::logger,"inside doSimpleInsert");
370
371			//if(!isNotNullKeySet(aRow)) {
372			this->fixPKWithSeq(aRow);
373			//this->setTimeInRow(aRow);
374			//this->setPersonInRow(aRow);
375			if(!util.isKeySet(aRow, notNullKeys->begin(), notNullKeys->end()) ) {
376			string message = "Coloumn name "+*util.getNullKey(aRow, notNullKeys->begin(), notNullKeys->end())+" is NULL";
377			LOG4CXX_ERROR(TableTemplate::logger,message);
378			throw ObjectLayerException(message);
379
380			}
381			//this->fixPKWithSeq(aRow);
382			//if(isPrimaryKeySet(aRow)) {
383			//if( util.isKeySet(aRow, primaryKeys->begin(), primaryKeys->end()) ) {
384			if( util.isKeySet(aRow, primaryKeysReal.begin(), primaryKeysReal.end()) ) {
385			vector<string> strQuery = this->makeInsertQuery(aRow);
386			typedef vector<string>::iterator QueryIter;
387			for(QueryIter qi = strQuery.begin(); qi != strQuery.end(); ++qi ) {
388			//cout<<"Query to execute is "<<endl<<*qi<<endl;
389
390			LOG4CXX_INFO(TableTemplate::logger,"Query is "+*qi);
391			int returnCode = dbmanager->executeQuery(*qi);
392			if(returnCode != 0) {
393			throw ObjectLayerException("Query: "+*qi+" could not be executed");
394			}
395			}
396			} else {
397			throw ObjectLayerException("Sequencers falied to set Primary key ");
398			}
399			}
400
401
402			template <class R>
403			void TableTemplate<R>::delRows() {
404			cout<<"ERASING rows"<<endl;
405			rows.clear();
406			}
407
408
409			template <class R>
410			void TableTemplate<R>::insertSingle(R* aRow, string name, string fkey) {
411			name += "row";
412			cout<<"name is "<<name<<" fkey is "<<fkey<<endl;
413			RowInterface* subRow = (RowInterface*)aRow->getConstituentRow(name,fkey);
414			cout<<"RowInterface* subRow = (RowInterface*)aRow->getConstituentRow(name,fkey) "<<endl;
415			TableFactory tf;
416			//cout<<"calling tf.getTableObject"<<endl;
417			TableInterface* ti = tf.getTableObject(name);
418			ti->setDBManager(dbmanager);
419			//cout<<"Done calling tf.getTableObject"<<endl;
420			ti->addRow(subRow);
421			ti->insert();
422			ti->delRows();
423			delete ti;
424
425			util.equatePKWithRef(aRow, refrences->begin(), refrences->end() );
426			util.equatePKWithMultiRef(aRow, multiRefrences->begin(), multiRefrences->end() );
427
428			}
429
430
431
432
433			template <class R>
434			void TableTemplate<R>::insertMulti(R* aRow, string name) {
435			bool exceptionOccured = false;
436			string exceptionMessage = "\n";
437
438			for(Dictionary_iter m = multiRefrences->begin(); m != multiRefrences->end(); ++m) {
439			try {
440			//cout<<"checking name "<<name<<" with util.getTokenAt(m->second,0) "<<util.getTokenAt(m->second,0)<<endl;
441			if(name == util.getTokenAt(m->second,0) ) {
442			this->insertSingle(aRow, name, m->first);
443			}
444			} catch (ObjectLayerException &e) {
445			exceptionOccured = true;
446			exceptionMessage += "At row "+name+": "+ e.report() + " \n";
447			} catch (DBException &e) {
448			exceptionOccured = true;
449			exceptionMessage += "At row "+name+": "+ e.report() + " \n";
450			} catch (exception &e) {
451			exceptionOccured = true;
452			exceptionMessage += "At row "+name+": "+ e.what() + " \n";
453			}
454
455			}
456			if(exceptionOccured) {
457			throw ObjectLayerException(exceptionMessage);
458			}
459			}
460
461			/*
462			template <class R>
463			void TableTemplate<R>::doSmartInsert(R* aRow) {
464			//cout<<"inside doSmartInsert for TableTemplate"<<endl;
465			LOG4CXX_DEBUG(TableTemplate::logger,"inside doSmartInsert for TableTemplate");
466			bool exceptionOccured = false;
467			string exceptionMessage = "\n";
468
469			for(Keys_iter i = schemaOrder->begin(); i != schemaOrder->end(); ++i) {
470			try{
471			if( util.isInMultiRef(*i, multiRefrences->begin(), multiRefrences->end()) ) {
472			this->insertMulti(aRow,*i);
473			} else {
474			this->insertSingle(aRow, *i,"");
475			}
476			} catch (ObjectLayerException &e) {
477			exceptionOccured = true;
478			exceptionMessage += "At row "+*i+": "+ e.report() + " \n";
479			} catch (DBException &e) {
480			exceptionOccured = true;
481			exceptionMessage += "At row "+*i+": "+ e.report() + " \n";
482			} catch (exception &e) {
483			exceptionOccured = true;
484			exceptionMessage += "At row "+*i+": "+ e.what() + " \n";
485			}
486
487
488			}
489			if(exceptionOccured) {
490			throw ObjectLayerException(exceptionMessage);
491			}
492			}
493			*/
494
495			template <class R>
496			void TableTemplate<R>::update(){
497			cout << "Hello I am in Update" << endl;
498			}
499
500			template <class R>
501			int TableTemplate<R>::getSeqValue(string tableName, string colName) {
502			ResultSet* rs = this->doSelect(sql->makeSeqQuery(tableName,colName),"");
503			if(rs->getNoOfRows() == 0) {
504			delete rs;
505			return 0;
506			}
507			int intValue = atoi(rs->getElement(0,0).c_str());
508			delete rs;
509			return ++intValue;
510
511			}
512
513			template <class R>
514			void TableTemplate<R>::fixPKWithSeq(R* aRow) {
515			for(Keys_iter i = primaryKeysReal.begin(); i != primaryKeysReal.end(); ++i) {
516			string dataType = util.getDataType(*i);
517			if( util.isSet(aRow, *i, dataType) ) {
518			continue;
519			}
520			if(dataType != "INTEGER") {
521			//cout<<"Sequencer for non int type is invalid"<<endl;
522			LOG4CXX_ERROR(TableTemplate::logger,"Sequencer for non int type is invalid");
523			continue;
524			}
525			int value = this->getSeqValue(util.getTokenAt(i, 0), util.getTokenAt(i, 1));
526			cout<<"Setting sequencer value of "<<*i<<" "<<value<<endl;
527			//LOG4CXX_DEBUG(TableTemplate::logger,"Setting sequencer value of " + *i + " " + value);
528			aRow->setValue(*i,&value);
529			}
530			}
531
532			template <class R>
533			void TableTemplate<R>::setTimeInRow(R* aRow) {
534			string tableName = this->util.getTokenAt(schema->begin()->first,0);
535			long value = this->util.getTime();
536			//float value = this->util.getTime();
537			//cout<<"setting "<<tableName<<".created_at to "<<value<<endl;
538			aRow->setValue(tableName+".created_at",&value);
539			aRow->setValue(tableName+".modified_at",&value);
540			}
541
542			template <class R>
543			void TableTemplate<R>::setPersonInRow(R* aRow) {
544			string tableName = this->util.getTokenAt(schema->begin()->first,0);
545			int value = 1;
546			aRow->setValue(tableName+".created_by",&value);
547			aRow->setValue(tableName+".modified_by",&value);
548			}
549
550			template TableTemplate<T_Schema_Revisionrow>;
551			template TableTemplate<T_Personrow>;
552			template TableTemplate<T_Physics_Grouprow>;
553			template TableTemplate<T_Collection_Typerow>;
554			template TableTemplate<T_App_Familyrow>;
555			template TableTemplate<T_Applicationrow>;
556			template TableTemplate<T_App_Configrow>;
557			template TableTemplate<T_Desc_Triggerrow>;
558			template TableTemplate<T_Desc_Mcrow>;
559			template TableTemplate<T_Desc_Primaryrow>;
560			template TableTemplate<T_Data_Tierrow>;
561			template TableTemplate<T_Primary_Datasetrow>;
562			template TableTemplate<T_Processing_Pathrow>;
563			template TableTemplate<T_Processed_Datasetrow>;
564			template TableTemplate<T_Event_Collectionrow>;
565			template TableTemplate<T_Analysis_Datasetrow>;
566			template TableTemplate<T_Anads_Datarow>;
567			template TableTemplate<T_Parentage_Typerow>;
568			template TableTemplate<T_Evcoll_Parentagerow>;
569			template TableTemplate<T_Block_Statusrow>;
570			template TableTemplate<T_Blockrow>;
571			template TableTemplate<T_File_Statusrow>;
572			template TableTemplate<T_File_Typerow>;
573			template TableTemplate<T_Filerow>;
574			template TableTemplate<T_Evcoll_Filerow>;
575			template TableTemplate<T_Validation_Statusrow>;
576			template TableTemplate<T_Dataset_Statusrow>;
577			template TableTemplate<T_Evcoll_Statusrow>;
578			template TableTemplate<T_Run_Qualityrow>;
579			template TableTemplate<T_Info_Anadsrow>;
580			template TableTemplate<T_Info_Evcollrow>;
581			template TableTemplate<T_Runrow>;
582			template TableTemplate<T_Evcoll_Runrow>;
583			template TableTemplate<Insertappsmultirow>;
584			template TableTemplate<Personmultirow>;
585			template TableTemplate<Physicsgroupmultirow>;
586			template TableTemplate<Evcollviewmultirow>;
587			template TableTemplate<Fileviewmultirow>;
588			template TableTemplate<Primarydatasetmultirow>;
589			template TableTemplate<Processingpathmultirow>;
590			template TableTemplate<Analysisdatasetmultirow>;
591			template TableTemplate<Datasetprovenenceevchildmultirow>;
592			template TableTemplate<Datasetprovenenceevparentmultirow>;
593			template TableTemplate<Crabevcollviewmultirow>;
594
595