StDbSql Class Reference

#include <StDbSql.hh>

Inheritance diagram for StDbSql:

List of all members.

Public Member Functions
	StDbSql (MysqlDb &db, StDbBuffer &buffer)
	StDbSql (MysqlDb &db, StDbBuffer &buffer, StDbType type, StDbDomain domain)
	StDbSql (MysqlDb &db, StDbBuffer &buffer, const char *typeName, const char *domainName)
virtual	~StDbSql ()
virtual void	use ()
virtual void	close ()
virtual void	clear ()
virtual int	QueryDb (StDbConfigNode *node)
virtual int	QueryDb (StDbNode *node)
virtual int	QueryDb (StDbTable *table, unsigned int reqTime)
virtual int	QueryDb (StDbTable *table, const char *whereClause)
virtual unsigned int *	QueryDbTimes (StDbTable *table, const char *whereClause, int opt=0)
virtual int	QueryDbFunction (StDbTable *table, const char *whereClause, char *funcName)
virtual int	QueryDescriptor (StDbTable *table)
virtual int	WriteDb (StDbTable *table, unsigned int storeTime)
virtual int	WriteDb (StDbConfigNode *node, int parentID, int &configID)
virtual int	storeConfigNode (StDbConfigNode *node)
virtual int	storeTableNode (StDbTable *table)
virtual bool	insertNodeRelation (int configID, int parent, int child)
virtual bool	rollBack (StDbNode *node)
virtual bool	rollBack (StDbTable *table)
virtual unsigned int	getUnixTime (const char *time)
virtual char *	getDateTime (unsigned int time)
virtual int *	selectElements (const char *elementName, StDbElementIndex *inval, int &numElements)
char *	getDataTable (StDbTable *table, unsigned int time)
char **	getDataTables (StDbTable *table, int &numTables)
void	setDbUtils (MysqlDb &db, StDbBuffer &buffer)
void	setDefaultReturnValues (StDbTable *table, unsigned int reqTime)
void	setDefaultBeginTime (StDbTable *table, unsigned int reqTime)
void	setDefaultEndTime (StDbTable *table)
char **	getIndexNames (const char *elementName, int &numIndexes)
Public Attributes
MysqlDb &	Db
StDbBuffer &	buff
Protected Member Functions
StDbTableDescriptor *	findDescriptor (int structID, int schemaID)
StDbTableDescriptor *	getDescriptor (int structID, int schemaID)
void	addDescriptor (StDbTableDescriptor *td)
void	deleteDescriptors ()
void	deleteDescriptor (int structID, int schemaID)
int	prepareNode (StDbNode *node)
int	queryNode (StDbNode *node)
bool	readNodeInfo (StDbNode *node)
bool	readConfigNodeInfo (StDbConfigNode *node)
bool	readTableInfo (StDbTable *table)
bool	checkValue (const char *colName, const char *colValue)
bool	checkForNull (const char *src)
char *	insertNodeString (StDbNode *node)
char *	getFlavorQuery (const char *flavor)
char *	getProdTimeQuery (unsigned int prodTime)
char *	getElementList (int *elements, int num)
char *	getElementListIN (int *elements, int num)
char *	getColumnList (StDbTable *table, char *tableName=0, char *funcName=0)
char *	getEmptyString ()
bool	hasInstance (StDbTable *table)
void	checkTableCatalog ()
char *	checkTablePrepForQuery (StDbTable *table, bool checkIndexed=false)
void	deleteRows (const char *tableName, int *rowID, int nrows)
void	initEndTime ()
char *	mRetString (StString &rs)
int	sendMess (const char *a, const char *b, StDbMessLevel m, int lineNum=0, const char *className=" ", const char *methName=" ")
bool	checkColumn (const char *tableName, const char *columnName)
bool	updateEndTime (StDbTable *table, const char *dataTable, unsigned int reqTime)
void	init ()
virtual int	WriteDbNoIndex (StDbTable *table, unsigned int storeTime)
Protected Attributes
StDbManager *	mgr
DescList	mdescriptors
char *	mretString
int	mtableCatalog
char *	mdefaultEndDateTime
unsigned int	mdefaultEndTime

---

Constructor & Destructor Documentation

StDbSql::StDbSql (  MysqlDb &  db, StDbBuffer &  buffer )

Definition at line 148 of file StDbSql.cc. : StDataBaseI(),Db(db), buff(buffer) { mgr=StDbManager::Instance(); init(); }

StDbSql::StDbSql (  MysqlDb &  db, StDbBuffer &  buffer, StDbType  type, StDbDomain  domain )

Definition at line 152 of file StDbSql.cc. : StDataBaseI(tpe, dom), Db(db), buff(buffer) { mgr=StDbManager::Instance(); init(); }

StDbSql::StDbSql (  MysqlDb &  db, StDbBuffer &  buffer, const char *  typeName, const char *  domainName )

Definition at line 158 of file StDbSql.cc. : StDataBaseI(tpe, dom), Db(db), buff(buffer){ mgr=StDbManager::Instance(); init(); }

StDbSql::~StDbSql (   )  [virtual]

Definition at line 164 of file StDbSql.cc. { if(mretString) delete [] mretString; if(mdefaultEndDateTime) delete [] mdefaultEndDateTime; deleteDescriptors(); }

---

Member Function Documentation

void StDbSql::addDescriptor (  StDbTableDescriptor *  td  )  [protected]

Definition at line 1068 of file StDbSql.cc. { mdescriptors.push_back( new StDbTableDescriptor((*td)) ); // add a copy };

bool StDbSql::checkColumn (  const char *  tableName, const char *  columnName )  [protected]

Definition at line 442 of file StDbSql.cc. { bool retVal=false; Db<<"show columns from "<<tableName<<" like '"<<columnName<<"'"<<endsql; if(Db.NbRows()==1)retVal=true; Db.Release(); return retVal; }

bool StDbSql::checkForNull (  const char *  src  )  [protected]

Definition at line 1523 of file StDbSql.cc. { return (strstr(src,"null")) ? true : false; }

void StDbSql::checkTableCatalog (   )  [protected]

Definition at line 1614 of file StDbSql.cc. { // if(Db.checkForTable("tableCatalog"))mtableCatalog=1 Db<<"show tables like 'tableCatalog'"<<endsql; if(Db.NbRows()==0){ mtableCatalog=1; } else { mtableCatalog=2; } Db.Release(); }

char * StDbSql::checkTablePrepForQuery (  StDbTable *  table, bool  checkIndexed = false )  [protected]

Definition at line 1501 of file StDbSql.cc. { if(mretString){ delete [] mretString; mretString=new char[256]; }else{mretString=new char[256];} if(!QueryDescriptor(table)) return strcpy(mretString," doesn't have a descriptor "); if(table->IsBinary()) return strcpy(mretString," Binary Store is currently disabled "); if(checkIndexed && !table->IsIndexed()) return strcpy(mretString," Table is not time indexed"); delete [] mretString; return mretString=0; }

bool StDbSql::checkValue (  const char *  colName, const char *  colValue )  [protected]

Definition at line 1366 of file StDbSql.cc. { bool retVal = false; char* tmpS=0; if(buff.ReadScalar(tmpS,colName) && strcmp(tmpS,colValue)==0)retVal=true; if(tmpS) delete [] tmpS; return retVal; }

void StDbSql::clear (   )  [inline, virtual]

Definition at line 222 of file StDbSql.hh. { Db.Release(); buff.Raz(); };

void StDbSql::close (   )  [inline, virtual]

Implements StDataBaseI. Definition at line 221 of file StDbSql.hh. { Db.Close(); };

void StDbSql::deleteDescriptor (  int  structID, int  schemaID )  [protected]

Definition at line 1091 of file StDbSql.cc. { StDbTableDescriptor* desc; for(DescList::iterator itr = mdescriptors.begin(); itr != mdescriptors.end(); ++itr){ if(structID==(*itr)->getStructID() && schemaID==(*itr)->getSchemaID()){ desc=(*itr); mdescriptors.erase(itr); delete [] desc; break; } } }

void StDbSql::deleteDescriptors (   )  [protected]

Definition at line 1074 of file StDbSql.cc. { DescList::iterator itr; StDbTableDescriptor* desc; do { for(itr=mdescriptors.begin(); itr != mdescriptors.end(); ++itr){ desc=*itr; mdescriptors.erase(itr); if(desc)delete desc; break; } } while (mdescriptors.begin() != mdescriptors.end() ); }

void StDbSql::deleteRows (  const char *  tableName, int *  rowID, int  nrows )  [protected]

Definition at line 945 of file StDbSql.cc. { if(!rowID || nrows==0)return; Db<<" delete from "<<tableName; Db<<" where dataID In("<<getElementList(rowID,nrows)<<")"<<endsql; }

StDbTableDescriptor * StDbSql::findDescriptor (  int  structID, int  schemaID )  [protected]

Definition at line 1044 of file StDbSql.cc. { StDbTableDescriptor* td = 0; for(DescList::iterator itr = mdescriptors.begin(); itr != mdescriptors.end(); ++itr){ if( ((*itr)->getSchemaID()==schemaID) && ((*itr)->getStructID()==structID)){ td = *itr; break; } } return td; }

char * StDbSql::getColumnList (  StDbTable *  table, char *  tableName = 0, char *  funcName = 0 )  [protected]

Definition at line 1466 of file StDbSql.cc. { StTableDescriptorI* desc=table->getDescriptor(); int numElements=desc->getNumElements(); StString es; es<<" "; int icount=0; for(int i=0;i<numElements;i++){ if(funcName && (desc->getElementLength(i)>1))continue; char* name=desc->getElementName(i); if(funcName)es<<funcName<<"("; if(tableName)es<<tableName<<"."; es<<name; if(funcName)es<<") as "<<name; if(i<(numElements-1))es<<", "; delete [] name; icount++; } if(icount) return mRetString(es); return (char*) 0; }

char * StDbSql::getDataTable (  StDbTable *  table, unsigned int  time )

Definition at line 1529 of file StDbSql.cc. { if(mtableCatalog==0) checkTableCatalog(); if(mtableCatalog==1) return table->getCstructName(); char* retVal=0; clear(); // as of now, just use name... later maybe more so I've sent in StDbTable* char* tableName=table->printName(); Db<<" select * from tableCatalog where nodeName='"<<tableName<<"'"; Db<<" AND unix_timestamp(beginTime)<="<<time; Db<<" Order by beginTime desc limit 1"<<endsql; if(Db.Output(&buff))buff.ReadScalar(retVal,"tableName"); clear(); return (retVal) ? retVal : table->getCstructName(); }

char ** StDbSql::getDataTables (  StDbTable *  table, int &  numTables )

Definition at line 1551 of file StDbSql.cc. { char** retVal; if(mtableCatalog==0) checkTableCatalog(); if(mtableCatalog==1){ numTables=1; retVal=new char*[1]; retVal[0]=table->getCstructName(); return retVal; } clear(); // as of now, just use name... later maybe more so I've sent in StDbTable* char* tableName=table->printName(); Db<<" select * from tableCatalog where nodeName='"<<tableName<<"'"<<endsql; if(!((numTables)=Db.NbRows()) ){ // use tableName as the 1 numTables++; retVal= new char*[numTables]; retVal[0]=new char[strlen(tableName)+1]; strcpy(retVal[0],tableName); return retVal; } retVal=new char*[numTables]; int i=0; while(Db.Output(&buff)) if(buff.ReadScalar(retVal[i],"tableName"))i++; numTables=i; return retVal; }

char * StDbSql::getDateTime (  unsigned int  time  )  [virtual]

Implements StDataBaseI. Definition at line 1350 of file StDbSql.cc. { char* retVal=0; // note the " + 0" part formats result without delimiters // e.g. 1999-01-01 00:12:20 becomes 19990101001220 clear(); Db<<"select from_unixtime("<<time<<") + 0 as requestTime"<<endsql; if(Db.Output(&buff)) buff.ReadScalar(retVal,"requestTime"); clear(); return retVal; }

StDbTableDescriptor * StDbSql::getDescriptor (  int  structID, int  schemaID )  [protected]

Definition at line 1059 of file StDbSql.cc. { StDbTableDescriptor* retVal=findDescriptor(structID,schemaID); if(retVal) return new StDbTableDescriptor(*retVal); // make copy retVal=new StDbTableDescriptor(structID,schemaID); // -else- make new return retVal; }

char * StDbSql::getElementList (  int *  elements, int  num )  [protected]

Definition at line 1419 of file StDbSql.cc. { // prepares comma separated list of integers // using the between operator StString es; if(!e){ es<<0; } else { // for(int i=0;i<num-1;i++)//es<<e[i]<<","; { //MPD // if (e[0] == 0){ if (num == 1){ es<<"= "<<e[0]; } else if(e[0]< num) { es<<"between "<<e[0]<<" and "<<num; } else { es<<"between "<<num <<" and "<<e[0]; } } // es<<e[num-1]; } return mRetString(es); }

char * StDbSql::getElementListIN (  int *  elements, int  num )  [protected]

Definition at line 1447 of file StDbSql.cc. { // prepares comma separated list of integers // using the IN operator StString es; if(!e){ es<<0; } else { es<<"In ("; for(int i=0;i<num-1;i++) es<<e[i]<<","; es<<e[num-1]; } es<<")"; return mRetString(es); }

char * StDbSql::getEmptyString (   )  [protected]

Definition at line 1492 of file StDbSql.cc. { StString es; es<<" "; return mRetString(es); };

char * StDbSql::getFlavorQuery (  const char *  flavor  )  [protected]

Definition at line 1378 of file StDbSql.cc. { // prepares SQL of " flavor In('flav1','flav2',...)" char *id1,*id2,*id3; id1 = new char[strlen(flavor)+1]; strcpy(id1,flavor); id3=id1; StString fs; fs<<" flavor In("; while(( (id2)=strstr(id3,"+")) ){ *id2='\0'; fs<<"'"<<id3<<"',"; *id2='+'; id2++; id3=id2; } fs<<"'"<<id3<<"')"; delete [] id1; return mRetString(fs); }

char ** StDbSql::getIndexNames (  const char *  elementName, int &  numIndexes )

Definition at line 1022 of file StDbSql.cc. { Db<<"select * from elementIndexes "; Db<<" where elementName='"<<elementName<<"'"<<endsql; char** indexNames = 0; if(!((numIndexes)=Db.NbRows())) return indexNames; indexNames = new char*[numIndexes]; int i = 0; while(Db.Output(&buff)){ buff.ReadScalar(indexNames[i],"indexName"); i++; buff.Raz(); } clear(); return indexNames; }

char * StDbSql::getProdTimeQuery (  unsigned int  prodTime  )  [protected]

Definition at line 1404 of file StDbSql.cc. { // prepares SQL of " entryTime<=" StString pt; if(prodTime==0){ pt<<" deactive=0 "; } else { pt<<" (deactive=0 OR deactive>="<<prodTime<<")"; pt<<" AND unix_timestamp(entryTime)<="<<prodTime; } return mRetString(pt); }

unsigned int StDbSql::getUnixTime (  const char *  time  )  [virtual]

Implements StDataBaseI. Definition at line 1337 of file StDbSql.cc. { unsigned int retVal = 0; clear(); Db<<"select unix_timestamp('"<<time<<"') as requestTime"<<endsql; if(Db.Output(&buff)) buff.ReadScalar(retVal,"requestTime"); clear(); return retVal; }

bool StDbSql::hasInstance (  StDbTable *  table  )  [protected]

Definition at line 1585 of file StDbSql.cc. { // try and find a data instance of this table // for use in keeping track of baseline instances bool retVal=false; clear(); int numTables; char** dataTables=getDataTables(table,numTables); if(numTables==0) return retVal; for(int i=0; i<numTables;i++){ Db<<" select * from "<<dataTables[i]; Db<<" where "<<getFlavorQuery(table->printFlavor()); Db<<" AND "<<getProdTimeQuery(table->getProdTime())<<endsql; if(Db.NbRows() !=0 ){ retVal=true; break; } } for(int k=0;k<numTables;k++) delete [] dataTables[k]; delete [] dataTables; return retVal; }

void StDbSql::init (   )  [inline, protected]

Definition at line 214 of file StDbSql.hh. { mretString = 0; mtableCatalog=0; mdefaultEndDateTime = 0; }

void StDbSql::initEndTime (   )  [protected]

Definition at line 1131 of file StDbSql.cc. { mdefaultEndTime=StDbDefaults::Instance()->getEndTime(); mdefaultEndDateTime=getDateTime(mdefaultEndTime); }

bool StDbSql::insertNodeRelation (  int  configID, int  parent, int  child )  [virtual]

Implements StDataBaseI. Definition at line 1324 of file StDbSql.cc. { Db<<" insert into NodeRelation set ParentID="<<parent; Db<<", NodeID="<<child<<", ConfigID="<<configID<<endsql; bool retVal=Db.QueryStatus(); Db.Release(); return retVal; }

char * StDbSql::insertNodeString (  StDbNode *  node  )  [protected]

Definition at line 1265 of file StDbSql.cc. { StString dqs; dqs<<"insert into Nodes set name='"<<node->printName()<<"' "; if(!StDbDefaults::Instance()->IsDefaultVersion(node->printVersion())) dqs<<", versionKey='"<<node->printVersion()<<"' "; dqs<<", nodeType='"<<node->printNodeType()<<"'"; return mRetString(dqs); }

char * StDbSql::mRetString (  StString &  rs  )  [inline, protected]

Definition at line 201 of file StDbSql.hh. { if(mretString)delete [] mretString; string srs=rs.str(); mretString = new char[srs.length()+1]; strcpy(mretString,srs.c_str()); return mretString; }

int StDbSql::prepareNode (  StDbNode *  node  )  [protected]

Definition at line 1138 of file StDbSql.cc. { //-> takes the input dbNode's name & version and calls the db // (via method queryNode()) for the other information // and sets into dbNode if( (strcmp(dbNode->printNodeType(),"DB")!=0) && (dbNode->IsConfigured())) return dbNode->getNodeID(); dbNode->setDbName(mdbName); dbNode->setDbType(mdbType); dbNode->setDbDomain(mdbDomain); return queryNode(dbNode);; }

int StDbSql::QueryDb (  StDbTable *  table, const char *  whereClause )  [virtual]

Implements StDataBaseI. Definition at line 484 of file StDbSql.cc. { #define __METHOD__ "QueryDb(StDbTable*, const char* where)" unsigned int* timeSet=QueryDbTimes(table,whereClause); if(!timeSet)return 0; delete [] timeSet; return table->GetNRows(); #undef __METHOD__ }

int StDbSql::QueryDb (  StDbTable *  table, unsigned int  reqTime )  [virtual]

Implements StDataBaseI. Definition at line 255 of file StDbSql.cc. { #define __METHOD__ "QueryDb(table,time)" // Using name & version information in StDbTable + request timestamp // fill data from the database into the StDbTable pointer. // int retVal=1; if(!table) return 0; char* tName = table->printName(); table->clearStoreInfo(); int nodeID; if(!((nodeID)=table->getNodeID())){ if(!(prepareNode((StDbNode*)table))) return sendMess(tName," Table not found in DB",dbMErr,__LINE__,__CLASS__,__METHOD__); readTableInfo(table); clear(); } char* checkString=checkTablePrepForQuery(table,true); // returns null if ok if(checkString) return sendMess(tName,checkString,dbMErr,__LINE__,__CLASS__,__METHOD__); // start preparing the queries // common where clause StString bs; bs<<" Where nodeID="<<nodeID; // prepare "flavor" part of query bs<<" AND "<<getFlavorQuery(table->printFlavor()); // prepare for production time bs<<" AND "<<getProdTimeQuery(table->getProdTime()); // terminate the baseString bs<<" "; string baseString = bs.str(); //--> add element ID list part of query int numRows; int* elementID=table->getElementID(numRows); if(!elementID) return sendMess(tName,"doesn't have an Element List",dbMErr,__LINE__,__CLASS__,__METHOD__); char* elementString=getElementList(elementID,numRows); char* dataTable=getDataTable(table,reqTime); // Query DB for the endtime -> earliest time of next row Db << " select beginTime + 0 as mendDateTime, "; Db << " unix_timestamp(beginTime) as mendTime from "<<dataTable; Db << baseString <<" AND beginTime>from_unixtime("<<reqTime<<")"; // Db << " And elementID In("<<elementString<<")"; Db << " And elementID "<<elementString; Db << " Order by beginTime limit 1"<<endsql; sendMess(DbQInfo,Db.printQuery(),dbMDebug,__LINE__,__CLASS__,__METHOD__); if(!Db.QueryStatus()) return sendMess(DbQFailed,Db.printQuery(),dbMWarn,__LINE__,__CLASS__,__METHOD__); if(Db.NbRows()==1 && Db.Output(&buff)){ char* edTime=0; int eTime; buff.ReadScalar(edTime,"mendDateTime"); buff.ReadScalar(eTime,"mendTime"); table->setEndTime(eTime); table->setEndTime(edTime); if(edTime) delete [] edTime; clear(); } else { setDefaultEndTime(table); } int eID; // --> prep for data query which can be 1 or more queries int maxID=1; int i; for(i=0;i<numRows;i++)if(elementID[i]>maxID)maxID=elementID[i]; int* idMap = new int[maxID+1]; int* dataIDList = new int[numRows]; unsigned int* timeValues = new unsigned int[numRows]; for(i=0;i<numRows;i++){ idMap[elementID[i]]=i; dataIDList[i]=0; timeValues[i]=0; } // --> end of prep <-- // query is done where elementID is not necessarily distinct. // yet the in the query we set limit=numRows. // - we take 1st of instance of each elementID returned. // - we make a new list of those not yet found // - redo query with limit="rowsLeft" // continue until we're done int rowsLeft=numRows; bool done=false; while(!done){ //done if all elementIDs are found or (break) if null Db <<" select unix_timestamp(beginTime) as bTime,"<<dataTable<<".* from "; Db << dataTable << baseString; Db <<" AND beginTime<=from_unixtime("<<reqTime<<")"; //Db <<" AND elementID In("<<elementString<<") "; Db <<" AND elementID "<<elementString; Db <<" Order by beginTime desc limit "<< rowsLeft <<endsql; sendMess(DbQInfo,Db.printQuery(),dbMDebug,__LINE__,__CLASS__,__METHOD__); if(!Db.QueryStatus()){ sendMess(DbQFailed,Db.printQuery(),dbMWarn,__LINE__,__CLASS__,__METHOD__); break; } if(Db.NbRows()==0)break; int numRowsFound=0; while(Db.Output(&buff)){ buff.ReadScalar(eID,"elementID"); // check to see if this eID is already returned & don't use if so if(!dataIDList[idMap[eID]]){ buff.ReadScalar(dataIDList[idMap[eID]],"dataID"); buff.ReadScalar(timeValues[idMap[eID]],"bTime"); table->setRowNumber(idMap[eID]); table->dbStreamer(&buff,true); // stream data into table numRowsFound++; } buff.Raz(); } rowsLeft=rowsLeft-numRowsFound; // Check for left overs & modify query for repeat if(!done && (rowsLeft>0)){ int* elementsLeft = new int[rowsLeft]; int j=0; for(i=0;i<numRows;i++){ if(!dataIDList[i]){ elementsLeft[j]=elementID[i]; j++; } } elementString = getElementListIN(elementsLeft,rowsLeft); delete [] elementsLeft; } else { done=true; } } // --> end of while loop if(rowsLeft==numRows){ sendMess(tName," has No data for query",dbMWarn,__LINE__,__CLASS__,__METHOD__); setDefaultBeginTime(table,reqTime); retVal=0; } else if(rowsLeft>0){ StString tp; tp<<" Not all rows filled from DB, Requested="<<numRows; tp<<" Returned="<<numRows-rowsLeft<<" for Table="<<tName; mgr->printInfo((tp.str()).c_str(),dbMWarn,__LINE__,__CLASS__,__METHOD__); // numRows-=rowsLeft; // table->resizeNumRows(numRows); } if(retVal){ table->addWrittenRows(dataIDList,numRows); table->setTimeValues(timeValues); unsigned int t1=table->getMaxTime(); table->setBeginTime(t1); char* dt=getDateTime(t1); table->setBeginTime(dt); delete [] dt; table->setRowNumber(); // reset current row to 0 } else { delete [] timeValues; } Db.Release(); if(retVal) retVal=(int)updateEndTime(table,dataTable,reqTime); delete [] idMap; delete [] dataIDList; delete [] dataTable; return retVal; #undef __METHOD__ }

int StDbSql::QueryDb (  StDbNode *  node  )  [virtual]

Implements StDataBaseI. Definition at line 239 of file StDbSql.cc. { #define __METHOD__ "QueryDb(StDbNode*)" if(!prepareNode(node)) return 0; if(node->IsTable()){ readTableInfo((StDbTable*) node); } else { readConfigNodeInfo((StDbConfigNode*)node); } return node->getNodeID(); #undef __METHOD__ }

int StDbSql::QueryDb (  StDbConfigNode *  node  )  [virtual]

Implements StDataBaseI. Definition at line 177 of file StDbSql.cc. { #define __METHOD__ "QueryDb(StDbConfigNode*)" StDbNode curNode; curNode.setDbName(mdbName); curNode.setDbType(mdbType); curNode.setDbDomain(mdbDomain); int NodeID; int branchID=node->getBranchID(); if(!((NodeID)=prepareNode(node)))return 0; // Build node query string Db<<"Select subNode.*, NodeRelation.ID as branchID from Nodes "; Db<<"LEFT JOIN NodeRelation ON Nodes.ID=NodeRelation.ParentID "; Db<<"LEFT JOIN Nodes as subNode ON NodeRelation.NodeID=subNode.ID "; Db<<" Where Nodes.ID="<<NodeID; Db<<" and NodeRelation.BranchID="<<branchID<<endsql; if(!Db.QueryStatus()) return sendMess(DbQFailed,Db.printQuery(),dbMWarn,__LINE__,__CLASS__,__METHOD__); if(!Db.NbRows()) sendMess(node->printName()," Node has no subnodes",dbMDebug,__LINE__,__CLASS__,__METHOD__); sendMess(DbQInfo,Db.printQuery(),dbMDebug,__LINE__,__CLASS__,__METHOD__); // // Loop over rows in Configuration while(Db.Output(&buff)){ curNode.setConfigured(false); if(readNodeInfo(&curNode)){ StString fs; fs<<"Found "<<curNode.printNodeType()<<" Node "<<curNode.printName(); fs<<" of parent "<<node->printName(); sendMess(DbQResult,(fs.str()).c_str(),dbMDebug,__LINE__,__CLASS__,__METHOD__); if(strcmp(curNode.printNodeType(),"table")!=0){ // it is a ConfigNode StDbConfigNode* child= new StDbConfigNodeImpl(node,curNode); if(!child->isDbNode())readConfigNodeInfo(child); } else { StDbTable* table = node->addTable(&curNode); readTableInfo(table); } } buff.Raz(); } Db.Release(); return 1; #undef __METHOD__ }

int StDbSql::QueryDbFunction (  StDbTable *  table, const char *  whereClause, char *  funcName )  [virtual]

Implements StDataBaseI. Definition at line 628 of file StDbSql.cc. { #define __METHOD__ "QueryDbFunction(table,whereClause,functionName)" /* Method to provide access to Max, Min, Ave,... functions where the result per storage table is put in a row in the StDbTable. This only works for those columns stored in basic Mysql types */ char* checkString=checkTablePrepForQuery(table); // null is good if(checkString) return sendMess(table->printName(),checkString,dbMErr,__LINE__,__CLASS__,__METHOD__); int numTables; int numRowsReturned=0; char** dataTables=getDataTables(table,numTables); int i; for(i=0;i<numTables;i++){ char* columnList=getColumnList(table,dataTables[i],funcName); if(!columnList)return 0; Db<<" select "<<columnList<<" from "<<dataTables[i]; Db<<" "<<whereClause<<endsql; sendMess(DbQInfo,Db.printQuery(),dbMDebug,__LINE__,__CLASS__,__METHOD__); if(!Db.QueryStatus()) return sendMess(DbQFailed,Db.printQuery(),dbMWarn,__LINE__,__CLASS__,__METHOD__); int retRows=Db.NbRows(); if(retRows==0) continue; numRowsReturned+=retRows; while(Db.Output(&buff)){ table->dbStreamer(&buff,true); buff.Raz(); } Db.Release(); } for(i=0;i<numTables;i++) delete [] dataTables[i]; delete [] dataTables; table->setRowNumber(); return numRowsReturned; #undef __METHOD__ };

unsigned int * StDbSql::QueryDbTimes (  StDbTable *  table, const char *  whereClause, int  opt = 0 )  [virtual]

Implements StDataBaseI. Definition at line 497 of file StDbSql.cc. { #define __METHOD__ "QueryDb(StDbTable*, const char* where)" /* rules for # of rows returned (by user request via setRowLimit(int nrows);) 1. table->GetNRows()= 0 or N means no limit or limit N 2. returned table->GetNRows()=M where M is how many returned rules for beginTime & endTime 1. Non-indexed tables have arbitrary returned times 2. beginTime="lastest" begin time of returned rows 3. endTime="earliest" begin time of set of "next" rows */ unsigned int* retVal=0; char* tName=table->printName(); char* checkString=checkTablePrepForQuery(table); if(checkString){ // then error message sendMess(tName,checkString,dbMErr,__LINE__,__CLASS__,__METHOD__); return retVal; } setDefaultReturnValues(table,0); int numRows = table->getRowLimit(); int numTables; int numRowsReturned=0; unsigned int t1=0; table->setElementID((int*)retVal,0); // no rows to begin with table->setRowNumber(); char** dataTables=getDataTables(table,numTables); int i; for(i=0;i<numTables;i++){ char* columnList=0; if(!opt)columnList=getColumnList(table,dataTables[i]); if(!opt && !columnList){ sendMess(tName," has no elements?",dbMErr,__LINE__,__CLASS__,__METHOD__); return retVal; } Db<<" select unix_timestamp("<<dataTables[i]<<".beginTime) as bTime,"; Db<<" elementID "; if(!opt)Db<<","<<columnList; Db<<" from "<<dataTables[i]<<" "<<whereClause; if(numRows)Db<<" limit "<<numRows; Db<<endsql; sendMess(DbQInfo,Db.printQuery(),dbMDebug,__LINE__,__CLASS__,__METHOD__); if(!Db.QueryStatus()){ sendMess(DbQFailed,Db.printQuery(),dbMWarn,__LINE__,__CLASS__,__METHOD__); return retVal; } int retRows=Db.NbRows(); if(retRows==0) continue; int* elements = new int[retRows]; int* dataIDList = new int[retRows]; unsigned int* timeList = new unsigned int[retRows]; if(!opt){ table->addNRows(retRows); } else { table->resizeElementID(retRows+table->GetNRows()); } // table->setRowNumber(); int j=0; while(Db.Output(&buff)){ buff.ReadScalar(timeList[j],"bTime"); buff.ReadScalar(elements[j],"elementID"); buff.ReadScalar(dataIDList[j],"dataID"); if(!opt)table->dbStreamer(&buff,true); if(timeList[j]>t1)t1=timeList[j]; j++; buff.Raz(); } table->addNElements(elements,retRows); table->addWrittenRows(dataIDList,retRows); table->setBeginTime(t1); unsigned int* tmpRet=new unsigned int[numRowsReturned+retRows]; if(retVal){ memcpy(tmpRet,retVal,numRowsReturned*sizeof(int)); delete [] retVal; } tmpRet+=numRowsReturned; memcpy(tmpRet,timeList,retRows*sizeof(int)); retVal=tmpRet; numRowsReturned+=retRows; Db.Release(); if(table->IsIndexed() && t1>0 && !opt){ Db<<" select unix_timestamp(beginTime) as eTime from "<<dataTables[i]; Db<<" where beginTime>from_unixtime("<<t1<<")"; //Db<<" and elementID In("<<getElementList(elements,retRows)<<")"; Db<<" and elementID "<<getElementList(elements,retRows); Db<<" Order by beginTime limit 1"<<endsql; sendMess(DbQInfo,Db.printQuery(),dbMDebug,__LINE__,__CLASS__,__METHOD__); if(Db.Output(&buff)){ unsigned int eTime=0; if(buff.ReadScalar(eTime,"eTime") && eTime && eTime<table->getEndTime())table->setEndTime(eTime); buff.Raz(); } Db.Release(); } delete [] elements; delete [] dataIDList; delete [] timeList; }// loop over tables for(i=0;i<numTables;i++) delete [] dataTables[i]; delete [] dataTables; if(retVal){ char* dateTime=getDateTime(table->getBeginTime()); table->setBeginTime(dateTime); if(dateTime) delete [] dateTime; dateTime=getDateTime(table->getEndTime()); table->setEndTime(dateTime); if(dateTime) delete [] dateTime; table->setRowNumber(); } return retVal; #undef __METHOD__ }

int StDbSql::QueryDescriptor (  StDbTable *  table  )  [virtual]

Implements StDataBaseI. Definition at line 833 of file StDbSql.cc. { #define __METHOD__ "QueryDescriptor(StDbTable*)" // Query the database for the elements associated with this // tableName and with the schemaID that is added at the // constructure or over-written by an input file ... e.g. requested SchemaID if(table->hasDescriptor())return 1; clear(); Db<<" SELECT structure.lastSchemaID, structure.ID from structure left join Nodes on structure.name=Nodes.structName"; Db<<" WHERE Nodes.name='"<<table->printName() <<"'"<<endsql; if(!Db.Output(&buff))return 0; int schemaID; int structID; buff.ReadScalar(schemaID,"lastSchemaID"); buff.ReadScalar(structID,"ID"); clear(); int requestSchemaID; if(!(requestSchemaID=table->getSchemaID())){ requestSchemaID=schemaID; table->setSchemaID(schemaID); } StDbTableDescriptor* descriptor = getDescriptor(structID,requestSchemaID); table->setDescriptor(descriptor); if(descriptor->IsValid())return 1; Db<<"SELECT schema.schemaID, schema.name, schema.type, schema.length, "; Db<<"schema.position from schema WHERE schema.structID="<<structID; Db<<" AND schema.schemaID="<<requestSchemaID; Db<<" ORDER by schema.position"<<endsql; sendMess(DbQInfo,Db.printQuery(),dbMDebug,__LINE__,__CLASS__,__METHOD__); if(!Db.QueryStatus()) return sendMess(DbQFailed,Db.printQuery(),dbMWarn,__LINE__,__CLASS__,__METHOD__); if(Db.NbRows()==0) { deleteDescriptor(structID,requestSchemaID); return 0; } while(Db.Output(&buff)){ descriptor->fillElement(&buff,requestSchemaID); buff.Raz(); } Db.Release(); descriptor->endRowPadding(); addDescriptor(descriptor); return 1; #undef __METHOD__ }

int StDbSql::queryNode (  StDbNode *  node  )  [protected]

Definition at line 1156 of file StDbSql.cc. { int retVal=0; Db<< "Select * from Nodes where Nodes.name='"<<node->printName()<<"'"; Db<<" AND Nodes.versionKey='"<<node->printVersion()<<"'"<<endsql; if(Db.Output(&buff) && readNodeInfo(node))retVal=node->getNodeID(); if(!retVal) clear(); return retVal; }

bool StDbSql::readConfigNodeInfo (  StDbConfigNode *  node  )  [protected]

Definition at line 1195 of file StDbSql.cc. { char* iname; if(!buff.ReadScalar(iname,"indexName")) return false; if(strcmp(iname,"None")!=0){ int id; buff.ReadScalar(id,"indexVal"); node->setElementIndexInfo(iname,id); } delete [] iname; int branchID; buff.ReadScalar(branchID,"branchID"); node->setBranchID(branchID); return true; }

bool StDbSql::readNodeInfo (  StDbNode *  node  )  [protected]

Definition at line 1171 of file StDbSql.cc. { int nodeID; char* tmpString; if(!buff.ReadScalar(nodeID,"ID")) return false; if(!buff.ReadScalar(tmpString,"nodeType"))return false; node->setNodeType(tmpString); delete [] tmpString; if(!buff.ReadScalar(tmpString,"name"))return false; node->setName(tmpString); delete [] tmpString; if(!buff.ReadScalar(tmpString,"versionKey"))return false; node->setVersion(tmpString); delete [] tmpString; node->setNodeID(nodeID); node->setConfigured(true); return true; }

bool StDbSql::readTableInfo (  StDbTable *  table  )  [protected]

Definition at line 1215 of file StDbSql.cc. { char* tmpString; if(!buff.ReadScalar(tmpString,"structName"))return false; table->setCstructName(tmpString); delete [] tmpString; tmpString=0; char* hy=0; if(buff.ReadScalar(tmpString,"elementID")){ hy=strstr(tmpString,"-"); if(hy){ *hy='\0'; hy++; int first=atoi(tmpString); int last = atoi(hy); hy--; *hy='-'; int len = last-first+1; int * tmpElements = new int[len]; int j=0; int k; for(k=first; k<=last;k++){ tmpElements[j]=k; j++; } table->setElementID(tmpElements,len); delete [] tmpElements; } else { delete [] tmpString; if(!buff.ReadScalar(tmpString,"indexName")) return false; table->setElementName(tmpString); } delete [] tmpString; } table->setBaseLine(checkValue("baseLine","Y")); table->setBinary(checkValue("isBinary","Y")); table->setIndexed(checkValue("isIndexed","Y")); table->setDbName(mdbName); table->setDbType(mdbType); table->setDbDomain(mdbDomain); return true; };

bool StDbSql::rollBack (  StDbTable *  table  )  [virtual]

Implements StDataBaseI. Definition at line 963 of file StDbSql.cc. { int numRows; int* numWrittenRows = table->getWrittenRows(numRows); char* dataTable = table->getDataTable(); char* elementList = getElementList(numWrittenRows,numRows); Db<<"delete from "<<dataTable<<" where dataID In("<<elementList<<")"<<endsql; Db.Release(); bool retVal=Db.QueryStatus(); Db.Release(); delete [] dataTable; return retVal; }

bool StDbSql::rollBack (  StDbNode *  node  )  [virtual]

Implements StDataBaseI. Definition at line 954 of file StDbSql.cc. { if(!(node->canRollBack()) || !(node->getNodeID())) return false; Db<<"delete from Nodes where ID="<<node->getNodeID()<<endsql; return Db.QueryStatus(); }

int * StDbSql::selectElements (  const char *  elementName, StDbElementIndex *  inval, int &  numElements )  [virtual]

Implements StDataBaseI. Definition at line 982 of file StDbSql.cc. { // if table does not have element rows (elementName=="None") // then will return default elementID=0, numElements=1 // if table does not have elements based on StDbElementIndex, // then will return null pointer & numElements=0 --> NO DATA CAN BE Gotten // else, will return element list & numElements based on query int* retElements = 0; numElements=1; if(!elementName) return retElements; if(strcmp(elementName,"None")==0){ retElements = new int[1]; retElements[0]=0; return retElements; } int numIndeces = inval->getNumIndeces(); clear(); Db<<" select elementID from "<<elementName<<"IDs"; if(numIndeces>0){ Db<<" where "<<inval->printIndexName(0)<<"="<<inval->getIndexVal(0); for(int i=1; i<numIndeces; i++) Db<<" AND "<<inval->printIndexName(i)<<"="<<inval->getIndexVal(i); } Db<<endsql; numElements=Db.NbRows(); if(numElements<=0) return retElements; retElements = new int[numElements]; int j=0; while(Db.Output(&buff)){ buff.ReadScalar(retElements[j],"elementID"); j++; buff.Raz(); } clear(); return retElements; }

int StDbSql::sendMess (  const char *  a, const char *  b, StDbMessLevel  m, int  lineNum = 0, const char *  className = " ", const char *  methName = " " )  [inline, protected]

Definition at line 209 of file StDbSql.hh. { if(m==dbMDebug && !(mgr->IsVerbose()))return 0; return mgr->printInfo(a,b,m,lineNum,className,methName); }

void StDbSql::setDbUtils (  MysqlDb &  db, StDbBuffer &  buffer )

Definition at line 1627 of file StDbSql.cc. { Db=db; buff=buffer; };

void StDbSql::setDefaultBeginTime (  StDbTable *  table, unsigned int  reqTime )

Definition at line 1115 of file StDbSql.cc. { // set default return times char* stime=getDateTime(reqTime); table->setBeginTime(reqTime); // uint version table->setBeginTime(stime); // char* version if(stime) delete [] stime; }

void StDbSql::setDefaultEndTime (  StDbTable *  table  )

Definition at line 1124 of file StDbSql.cc. { if(!mdefaultEndDateTime)initEndTime(); table->setEndTime(mdefaultEndDateTime); table->setEndTime(mdefaultEndTime); }

void StDbSql::setDefaultReturnValues (  StDbTable *  table, unsigned int  reqTime )

Definition at line 1107 of file StDbSql.cc. { if(!table)return; setDefaultBeginTime(table,reqTime); setDefaultEndTime(table); table->clearStoreInfo(); }

int StDbSql::storeConfigNode (  StDbConfigNode *  node  )  [virtual]

Implements StDataBaseI. Definition at line 1279 of file StDbSql.cc. { int retVal=0; Db<<insertNodeString((StDbNode*) node); if(node->getNumIndeces()){ char* ename=0; int eid; node->getElementIndexInfo(ename,eid); Db<<", indexName='"<<ename<<"'"; Db<<", indexVal="<<eid; if(ename) delete [] ename; } Db<<endsql; if(Db.QueryStatus())retVal=Db.GetLastInsertID(); clear(); return retVal; }

int StDbSql::storeTableNode (  StDbTable *  table  )  [virtual]

Implements StDataBaseI. Definition at line 1302 of file StDbSql.cc. { int retVal=0; if(!table->printCstructName()) return retVal; Db<<insertNodeString((StDbNode*) table); Db<<", structName='"<<table->printCstructName()<<"'"; if(table->IsBaseLine())Db<<", baseLine='Y'"; if(table->IsBinary())Db<<", isBinary='Y'"; if(!table->IsIndexed())Db<<", isIndexed='N'"; Db<<endsql; if(Db.QueryStatus())retVal=Db.GetLastInsertID(); clear(); return retVal; }

bool StDbSql::updateEndTime (  StDbTable *  table, const char *  dataTable, unsigned int  reqTime )  [protected]

Definition at line 452 of file StDbSql.cc. { /******************************** resets the table's endtime based on set endTime (if table has this column) instead of the running beginTime timestamp. Returns False if endTime is earlier than requestTime ********************************/ bool retVal = true; if(!checkColumn(dataTable,"endTime")) return retVal; int nrows; int* wrows = table->getWrittenRows(nrows); Db<<" select unix_timestamp(Min(endTime)) as mendTime from "<<dataTable; // Db<<" where dataID In("<<getElementList(wrows,nrows)<<")"<<endsql; Db<<" where dataID "<<getElementList(wrows,nrows)<<endsql; if( (Db.NbRows()>0) && Db.Output(&buff)){ unsigned int t1 = table->getEndTime(); unsigned int t2; buff.ReadScalar(t2,"mendTime"); if(t2<t1)table->setEndTime(t2); if(t2<requestTime) retVal=false; buff.Raz(); } Db.Release(); return retVal; }

void StDbSql::use (   )  [inline, virtual]

Implements StDataBaseI. Definition at line 220 of file StDbSql.hh. { Db.setDefaultDb(mdbName); };

int StDbSql::WriteDb (  StDbConfigNode *  node, int  parentID, int &  configID )  [virtual]

Implements StDataBaseI. Definition at line 897 of file StDbSql.cc. { #define __METHOD__ "WriteDb(node,parentID,configID)" if(!node) return 0; char* nName = node->printName(); if(!parentID){ if(strcmp(node->printNodeType(),"Config")!=0) return sendMess("No Config tag for new config=",nName,dbMErr,__LINE__,__CLASS__,__METHOD__); if(!node->printVersion()) return sendMess("No version label for new config=",nName,dbMErr,__LINE__,__CLASS__,__METHOD__); } else { node->setNodeType("directory"); } int nodeID; if(!((nodeID)=storeConfigNode(node))) return sendMess(" Could not store ",nName,dbMErr,__LINE__,__CLASS__,__METHOD__); // write this node if(parentID) { insertNodeRelation(configID,parentID,nodeID); } else { configID=node->getNodeID(); } // do this node's tables if(node->hasData()){ StDbTableIter* itr=node->getStDbTableIter(); while(!itr->done()){ int childID=0; StDbTable* table= itr->next(); table->setNodeType("table"); if(!((childID)=storeTableNode(table))) return sendMess(" Could not store table in Node=",nName,dbMErr,__LINE__,__CLASS__,__METHOD__); insertNodeRelation(configID,nodeID,childID); } } return nodeID; }

int StDbSql::WriteDb (  StDbTable *  table, unsigned int  storeTime )  [virtual]

Implements StDataBaseI. Definition at line 676 of file StDbSql.cc. { #define __METHOD__ "WriteDb(StDbTable*,uint storeTime)" int retVal=1; char* tName=table->printName(); if(!table->hasData()) return sendMess(tName," has no data to store",dbMWarn,__LINE__,__CLASS__,__METHOD__)+1; int nodeID; if(!((nodeID)=table->getNodeID())) if(!(prepareNode((StDbNode*)table))) return sendMess(tName," Not found in DB",dbMErr,__LINE__,__CLASS__,__METHOD__); readTableInfo(table); clear(); if(table->IsBaseLine() && hasInstance(table)) return sendMess("BaseLine instance already exists",tName,dbMErr,__LINE__,__CLASS__,__METHOD__); if(!QueryDescriptor(table)) return sendMess(tName," doesn't have a descriptor",dbMErr,__LINE__,__CLASS__,__METHOD__); table->setRowNumber(); // set to 0 if(!table->IsIndexed())return WriteDbNoIndex(table,storeTime); char* dataTable; if(!((dataTable)=getDataTable(table,storeTime))) return sendMess(tName," has no storage table",dbMErr,__LINE__,__CLASS__,__METHOD__); int numRows; int* elements = table->getElementID(numRows); if(!elements) return sendMess(tName,"doesn't have an Element List",dbMErr,__LINE__,__CLASS__,__METHOD__); int* storedData = new int[numRows]; memset(storedData,0,numRows*sizeof(int)); char* sTime = getDateTime(storeTime); int rowsWritten = 0; // write each row & roll back full writes if any fail. // - Also, for the time being, write to the old index // so that one can read with older versions of the code table->commitData(); table->clearStoreInfo(); table->setDataTable(dataTable); char* eTime=0; if( table->getEndStoreTime() && checkColumn(dataTable,"endTime")) eTime=getDateTime(table->getEndStoreTime()); for(int i=0;i<numRows;i++){ clear(); buff.WriteScalar(nodeID,"nodeID"); buff.WriteScalar(table->getSchemaID(),"schemaID"); buff.WriteScalar(sTime,"beginTime"); buff.WriteScalar(elements[i],"elementID"); if(eTime)buff.WriteScalar(eTime,"endTime"); if(!table->defaultFlavor())buff.WriteScalar(table->printFlavor(),"flavor"); table->dbStreamer(&buff,false); if(!Db.Input(dataTable,&buff)){ deleteRows(dataTable,storedData,i); retVal=0; break; } else { storedData[i]=Db.GetLastInsertID(); } clear(); rowsWritten++; } if(rowsWritten==numRows)table->addWrittenRows(storedData,numRows,true); delete [] storedData; delete [] sTime; if(eTime) delete [] eTime; table->setRowNumber(); delete [] dataTable; if(!retVal)sendMess(" Write failed for table=",tName,dbMWarn,__LINE__,__CLASS__,__METHOD__); return retVal; #undef __METHOD__ }

int StDbSql::WriteDbNoIndex (  StDbTable *  table, unsigned int  storeTime )  [protected, virtual]

Definition at line 768 of file StDbSql.cc. { #define __METHOD__ "WriteDbNoIndex(table,storeTime)" int retVal=0; char* dataTable; if(!((dataTable)=getDataTable(table,storeTime))) return sendMess(table->printName()," has no storage table",dbMErr,__LINE__,__CLASS__,__METHOD__); StString cList; cList<<"beginTime,"<<getColumnList(table); char* sTime=getDateTime(storeTime); int numRows=table->GetNRows(); char* colList = new char[strlen((cList.str()).c_str())+1]; strcpy(colList,(cList.str()).c_str()); int i; bool hasBinary=false; if(Db.InputStart(dataTable,&buff,colList,numRows,hasBinary)){ if(hasBinary){ // got to go through the buffer cout<<" In Binary write???"<<endl; for(i=0;i<numRows;i++){ buff.WriteScalar(sTime,"beginTime"); table->dbStreamerWrite(&buff); //,false); if(!Db.InputRow(&buff,i)) break; } if( i==numRows && Db.InputEnd() ){ retVal=1; table->commitData(); } } else { table->setBeginTime(storeTime); StString fsql; StDbFastSqlWriter writer(fsql); writer.ioTable(table); Db<<fsql.str(); if(Db.InputEnd()){ retVal=1; table->commitData(); } } } clear(); table->setRowNumber(); delete [] colList; delete [] sTime; delete [] dataTable; if(!retVal)sendMess(" Write failed for Non-Indexed table=",table->printName(),dbMWarn,__LINE__,__CLASS__,__METHOD__); return retVal; #undef __METHOD__ }

---

Member Data Documentation

StDbBuffer& StDbSql::buff

Definition at line 197 of file StDbSql.hh.

MysqlDb& StDbSql::Db

Definition at line 196 of file StDbSql.hh.

char* StDbSql::mdefaultEndDateTime [protected]

Definition at line 103 of file StDbSql.hh.

unsigned int StDbSql::mdefaultEndTime [protected]

Definition at line 104 of file StDbSql.hh.

DescList StDbSql::mdescriptors [protected]

Definition at line 99 of file StDbSql.hh.

StDbManager* StDbSql::mgr [protected]

Definition at line 96 of file StDbSql.hh.

char* StDbSql::mretString [protected]

Definition at line 101 of file StDbSql.hh.

int StDbSql::mtableCatalog [protected]

Definition at line 102 of file StDbSql.hh.

---

The documentation for this class was generated from the following files:

• StDbSql.hh
• StDbSql.cc

---