#include "DBFolder.h"

Public Member Functions
	DBFolder (const std::string &name, const std::string &url, const std::string &tag="")

virtual	~DBFolder ()

int	GetNamedChannelData (DBChannelID_t channel, const std::string &name, bool &data)

int	GetNamedChannelData (DBChannelID_t channel, const std::string &name, long &data)

int	GetNamedChannelData (DBChannelID_t channel, const std::string &name, double &data)

int	GetNamedChannelData (DBChannelID_t channel, const std::string &name, std::string &data)

int	GetNamedChannelData (DBChannelID_t channel, const std::string &name, std::vector< double > &data)

const std::string &	URL () const

const std::string &	FolderName () const

const std::string &	Tag () const

const IOVTimeStamp &	CachedStart () const

const IOVTimeStamp &	CachedEnd () const

bool	UpdateData (DBTimeStamp_t raw_time)

int	GetChannelList (std::vector< DBChannelID_t > &channels) const

Private Member Functions
size_t	GetTupleColumn (DBChannelID_t channel, const std::string &name, Tuple &tup)

bool	IsValid (const IOVTimeStamp &time) const

Private Attributes
std::string	fURL

std::string	fFolderName

std::string	fTag

int	fMaximumTimeout

Dataset	fCachedDataset

int	fNRows

IOVTimeStamp	fCachedStart

IOVTimeStamp	fCachedEnd

std::vector< std::string >	fColumns

std::vector< std::string >	fTypes

int	fCachedRow

DBChannelID_t	fCachedChannel

Detailed Description

Definition at line 15 of file DBFolder.h.

Constructor & Destructor Documentation

lariov::DBFolder::DBFolder	(	const std::string &	name,
		const std::string &	url,
		const std::string &	tag = `""`
	)

Definition at line 25 of file DBFolder.cxx.

References fCachedChannel, fCachedDataset, fCachedRow, fColumns, fFolderName, fMaximumTimeout, fNRows, fTag, fTypes, and fURL.

                                                                                         :
     fCachedStart(0,0), fCachedEnd(0,0) {
 
     fFolderName = name;
     fURL = url;
     fTag = tag;
     if (fURL[fURL.length()-1] == '/') {
       fURL = fURL.substr(0, fURL.length()-1);
     }
 
     fCachedDataset = 0;
     fNRows =0;
     fColumns.clear();
     fTypes.clear();
     fCachedRow = -1;
     fCachedChannel = 0;
     
     fMaximumTimeout = 4*60; //4 minutes
   }

lariov::DBFolder::~DBFolder ( )

virtual

Definition at line 45 of file DBFolder.cxx.

References fCachedDataset.

                       {
     if (fCachedDataset) releaseDataset(fCachedDataset);
   }

Member Function Documentation

const IOVTimeStamp& lariov::DBFolder::CachedEnd ( ) const

inline

Definition at line 32 of file DBFolder.h.

References fCachedEnd, GetChannelList(), GetTupleColumn(), and UpdateData().

32 {return fCachedEnd;}

lariov::DBFolder::fCachedEnd

IOVTimeStamp fCachedEnd

Definition: DBFolder.h:55

const IOVTimeStamp& lariov::DBFolder::CachedStart ( ) const

inline

Definition at line 31 of file DBFolder.h.

References fCachedStart.

31 {return fCachedStart;}

lariov::DBFolder::fCachedStart

IOVTimeStamp fCachedStart

Definition: DBFolder.h:54

const std::string& lariov::DBFolder::FolderName ( ) const

inline

Definition at line 28 of file DBFolder.h.

References fFolderName.

28 {return fFolderName;}

lariov::DBFolder::fFolderName

std::string fFolderName

Definition: DBFolder.h:48

int lariov::DBFolder::GetChannelList ( std::vector< DBChannelID_t > & channels ) const

Definition at line 156 of file DBFolder.cxx.

References fCachedDataset, fNRows, and lariov::kNUMBER_HEADER_ROWS.

Referenced by CachedEnd().

                                                                          {
     
     channels.clear();
     if (!fCachedDataset) return 1;
     
     Tuple tup;
     int err=0;
     for ( int row = 0; row != fNRows; ++row) {
       tup = getTuple(fCachedDataset, row + kNUMBER_HEADER_ROWS);
       channels.push_back( (DBChannelID_t)getLongValue(tup,0,&err) );
       releaseTuple(tup);
     }  
     return err;
   }

int lariov::DBFolder::GetNamedChannelData	(	DBChannelID_t	channel,
		const std::string &	name,
		bool &	data
	)

Definition at line 49 of file DBFolder.cxx.

References col, GetTupleColumn(), and lariov::kBUFFER_SIZE.

                                                                                             {
   
     Tuple tup;
     size_t col = this->GetTupleColumn(channel, name, tup);
     int err=0;
     char buf[kBUFFER_SIZE];
     int str_size = getStringValue(tup, col, buf, kBUFFER_SIZE, &err);
     data = false;
     if (std::string(buf, str_size)=="True") {
       data = true;
     }
     else if (std::string(buf, str_size)=="False") {
       data = false;
     }
     else std::cout<<"(DBFolder) ERROR: Can't identify data: "<<std::string(buf, str_size)<<" as boolean!"<<std::endl;
     
     releaseTuple(tup);
     return err;
   }

int lariov::DBFolder::GetNamedChannelData	(	DBChannelID_t	channel,
		const std::string &	name,
		long &	data
	)

Definition at line 69 of file DBFolder.cxx.

References col, GetTupleColumn(), and lariov::kBUFFER_SIZE.

                                                                                             {
 
     Tuple tup;
     size_t col = this->GetTupleColumn(channel, name, tup);
     int err=0;
     
     //first handle special case that the db data is boolean, but user mistakenly used long version of this function
     char buf[kBUFFER_SIZE];
     int str_size = getStringValue(tup, col, buf, kBUFFER_SIZE, &err);
     if (std::string(buf, str_size)=="True") {
       data = 1;
     }
     else if (std::string(buf, str_size)=="False") {
       data = 0;
     }
     else { //ok, we really have a long (hopefully)   
       data = getLongValue(tup, col, &err);
     }
     releaseTuple(tup);
     return err;
   }

int lariov::DBFolder::GetNamedChannelData	(	DBChannelID_t	channel,
		const std::string &	name,
		double &	data
	)

Definition at line 91 of file DBFolder.cxx.

References col, and GetTupleColumn().

                                                                                               {
 
     Tuple tup;
     size_t col = this->GetTupleColumn(channel, name, tup);
     int err=0;
     data = getDoubleValue(tup, col, &err);
     releaseTuple(tup);
     return err;
   }

int lariov::DBFolder::GetNamedChannelData	(	DBChannelID_t	channel,
		const std::string &	name,
		std::string &	data
	)

Definition at line 101 of file DBFolder.cxx.

References col, GetTupleColumn(), and lariov::kBUFFER_SIZE.

                                                                                                  {
 
     Tuple tup;
     size_t col = this->GetTupleColumn(channel, name, tup);
     int err=0;
     char buf[kBUFFER_SIZE];
     int str_size = getStringValue(tup, col, buf, kBUFFER_SIZE, &err);
     data = std::string(buf, str_size);
     releaseTuple(tup);
     return err;
   }

int lariov::DBFolder::GetNamedChannelData	(	DBChannelID_t	channel,
		const std::string &	name,
		std::vector< double > &	data
	)

Definition at line 113 of file DBFolder.cxx.

References col, lariov::DataRec::columns, GetTupleColumn(), lariov::kBUFFER_SIZE, and lariov::DataRec::ncolumns.

                                                                                                          {
     
     data.clear();
     
     Tuple tup;
     size_t col = this->GetTupleColumn(channel, name, tup);
     int err=0;
     double buf[kBUFFER_SIZE];
     
     DataRec *dataRec = (DataRec *)tup;
     // for c2: col is an unsigned int and cannot be less than 0
     // if (col < 0 || col >= dataRec->ncolumns) {
     if (col >= dataRec->ncolumns) {
       err=-1;
       return err;
     }
     
     char* sptr = dataRec->columns[col];
     if ( *sptr == '[') sptr +=1;  //expect an initial bracket and skip it
     else {
       err=-2;
       return err;
     }
     
     char* eptr;
     double val;
     unsigned int array_size=0;
     for (unsigned int i=0; i < kBUFFER_SIZE; ++i) {
       val = strtod(sptr, &eptr); //Try to convert
       if (sptr==eptr) break;     //conversion failed
       if (*sptr=='\0') break;    //end loop if buffer ends
       
       buf[array_size++] = val;
       
       if ( *eptr == ']') break;  //found the closing bracket, we're done
       else sptr = eptr+1;        //point to the next value
     }
     
     data.insert(data.begin(), buf, buf + array_size);
     releaseTuple(tup);
     return err;
   }

size_t lariov::DBFolder::GetTupleColumn	(	DBChannelID_t	channel,
		const std::string &	name,
		Tuple &	tup
	)

private

Definition at line 172 of file DBFolder.cxx.

References fCachedChannel, fCachedDataset, fCachedRow, fColumns, fNRows, lariov::kNUMBER_HEADER_ROWS, and util::flags::to_string().

Referenced by CachedEnd(), and GetNamedChannelData().

                                                                                            {
 
     //check if cached row is still valid
     int err;
     int row = -1;
     if (fCachedRow != -1 && fCachedChannel == channel) {
       tup = getTuple(fCachedDataset, fCachedRow + kNUMBER_HEADER_ROWS);
       if ( channel == (DBChannelID_t)getLongValue(tup,0,&err) ) {
         row = fCachedRow;
       }
       else releaseTuple(tup);
     }
 
     //if cached row is not valid, find the new row
     if (row == -1) {   
 //std::cout<<"Channel "<<channel<<" not cached"<<std::endl;
       //binary search for channel
       DBChannelID_t val;
       int l = 0, h = fNRows - 1;
       row = (l + h )/2;
       while ( l <= h ) {
 //std::cout<<"  "<<l<<"  "<<h<<"  "<<row<<std::endl;
         tup = getTuple(fCachedDataset, row + kNUMBER_HEADER_ROWS);
         val = getLongValue(tup, 0, &err);
         releaseTuple(tup);
 
         if (val == channel ) break;
           
         if (val > channel) h = row - 1;
         else            l = row + 1;
 
         row = (l + h)/2;
       }
       
       //get the tuple to be returned, check that the found row matches the requested channel
       tup = getTuple(fCachedDataset, row + kNUMBER_HEADER_ROWS); 
       if ( channel != (DBChannelID_t)getLongValue(tup, 0, &err) ) {
         releaseTuple(tup);
         std::string msg = "Channel " + std::to_string(channel) + " is not found in database!";
         throw WebError(msg);
       }
       
       
       //update caching info
       fCachedChannel = channel;
       fCachedRow = row;
     
     }
 
     //get the column corresponding to input string name and return
     for (size_t c=1; c < fColumns.size(); ++c ) {
       if (name == fColumns[c]) return c;
     }
 
     std::string msg = "Column named " + name + " is not found in the database!";
     throw WebError(msg);
     return 0;
   }

bool lariov::DBFolder::IsValid ( const IOVTimeStamp & time ) const

inlineprivate

Definition at line 41 of file DBFolder.h.

References fCachedEnd, and fCachedStart.

Referenced by UpdateData().

                                                    {
         if (time >= fCachedStart && time < fCachedEnd) return true;
         else return false;
       }

const std::string& lariov::DBFolder::Tag ( ) const

inline

Definition at line 29 of file DBFolder.h.

References fTag.

29 {return fTag;}

lariov::DBFolder::fTag

std::string fTag

Definition: DBFolder.h:49

bool lariov::DBFolder::UpdateData ( DBTimeStamp_t raw_time )

Definition at line 232 of file DBFolder.cxx.

References fCachedDataset, fCachedEnd, fCachedStart, fColumns, fFolderName, fMaximumTimeout, fNRows, fTag, fTypes, fURL, IsValid(), lariov::kBUFFER_SIZE, lariov::kNUMBER_HEADER_ROWS, and util::flags::to_string().

Referenced by CachedEnd().

                                                    {
   
     //convert to IOVTimeStamp
     IOVTimeStamp ts = TimeStampDecoder::DecodeTimeStamp(raw_time);
 
     //check if cache is updated
     if (this->IsValid(ts)) return false;
 
     int err=0;
 
     //release old dataset
     if (fCachedDataset) releaseDataset(fCachedDataset);
 
     //get full url string
     std::stringstream fullurl;
     fullurl << fURL << "/data?f=" << fFolderName
             << "&t=" << ts.DBStamp();
     if (fTag.length() > 0) fullurl << "&tag=" << fTag;
 
     //get new dataset
     int status = -1;
     fCachedDataset = getDataWithTimeout(fullurl.str().c_str(), NULL, fMaximumTimeout, &err);
     status = getHTTPstatus(fCachedDataset);
     
     //Can add some more queries here if we get http error 504
     /*if (status == 504) {
       //try again
     }*/
     
     if (status != 200) {
       std::string msg = "HTTP error from " + fullurl.str()+": status: " + std::to_string(status) + ": " + std::string(getHTTPmessage(fCachedDataset));
       throw WebError(msg);
     }
 
     //update info about cached data
     fNRows = getNtuples(fCachedDataset) - kNUMBER_HEADER_ROWS;
     //std::cout<<"Retrieved "<<fNRows<<" rows from "<<fullurl.str()<<std::endl;
     if (fNRows < 1) {
       std::stringstream msg;
       msg << "Time " << ts.DBStamp() << ": Data not found in database.";
       throw WebError(msg.str());
       fCachedStart = fCachedEnd = ts;
     }
 
     //start and end times
     Tuple tup;
     tup = getTuple(fCachedDataset, 0);   
     char buf[kBUFFER_SIZE];
     getStringValue(tup,0, buf, kBUFFER_SIZE, &err);
     fCachedStart = IOVTimeStamp::GetFromString(std::string(buf));
     releaseTuple(tup);
 
     tup = getTuple(fCachedDataset, 1);
     getStringValue(tup,0, buf, kBUFFER_SIZE, &err);
     if ( 0 == strcmp(buf,"-") ) {
       fCachedEnd = IOVTimeStamp::MaxTimeStamp();
     }
     else {
       fCachedEnd = IOVTimeStamp::GetFromString(std::string(buf));
     }
     releaseTuple(tup);
 
     //column names
     tup = getTuple(fCachedDataset, 2);
     fColumns.clear();
     for (int c=0; c < getNfields(tup); ++c) {
       getStringValue(tup, c, buf, kBUFFER_SIZE, &err);
       fColumns.push_back(buf);
     }
     releaseTuple(tup);
 
     //column types
     tup = getTuple(fCachedDataset, 3);
     fTypes.clear();
     for (int c=0; c < getNfields(tup); ++c) {
       getStringValue(tup, c, buf, kBUFFER_SIZE, &err);
       fTypes.push_back(buf);
     }
     releaseTuple(tup);
 
     return true;
   }