nutools::dbi::Table Class Reference

#include "Table.h"

Public Member Functions
	Table ()
	Table (std::string schemaName, std::string tableName, int tableType=kGenericTable, std::string dbhost="", std::string dbname="", std::string dbport="", std::string dbuser="")
	~Table ()
std::string	Name ()
std::string	DBName ()
std::string	DBHost ()
std::string	User ()
std::string	Role ()
std::string	DBPort ()
int	TableType ()
int	DataSource ()
int	DataTypeMask ()
void	SetTableName (std::string tname)
void	SetTableName (const char *tname)
void	SetDataSource (std::string ds)
void	SetDataSource (int ids)
bool	SetTableType (int t)
void	SetDataTypeMask (int mask)
void	SetIgnoreEnvVar (bool f)
void	SetUser (std::string uname)
void	SetUser (const char *uname)
bool	SetRole (std::string role)
bool	SetRole (const char *role)
void	SetDBName (std::string dbname)
void	SetDBName (const char *dbname)
void	SetDBHost (std::string dbhost)
void	SetDBHost (const char *dbhost)
void	SetDBPort (std::string p)
void	SetDBPort (const char *p)
void	SetDBInfo (std::string name, std::string host, std::string port, std::string user)
void	SetDBInfo (const char *name, const char *host, const char *port, const char *user)
bool	SetPasswordFile (const char *fname=0)
	fname should be the name of the file More...
void	ClearPassword ()
void	DisablePasswordAccess ()
void	ResetRole ()
void	SetVerbosity (int i)
int	NCol ()
int	NRow ()
void	Clear ()
void	ClearRows ()
nutools::dbi::Row *const	GetRow (int i)
void	AddRow (const Row *row)
void	AddRow (const Row &row)
int	AddCol (std::string cname, std::string ctype)
void	AddEmptyRows (unsigned int nrow)
bool	RemoveRow (int i)
nutools::dbi::Row *const	NewRow ()
std::vector< std::string >	GetColNames ()
std::map< std::string, int >	GetColNameToIndexMap ()
std::string	GetColName (int i)
int	GetColIndex (std::string cname)
const nutools::dbi::ColumnDef *	GetCol (int i)
const nutools::dbi::ColumnDef *	GetCol (std::string &cname)
const nutools::dbi::ColumnDef *	GetCol (const char *cname)
void	SetTolerance (std::string &cname, float t)
float	Tolerance (std::string &cname)
bool	ExistsInDB ()
bool	ExecuteSQL (std::string cmd, PGresult *&res)
bool	LoadFromCSV (std::string fname)
bool	LoadFromCSV (const char *fname)
bool	LoadFromDB ()
bool	WriteToDB (bool commit=true)
	use commit=false if just testing More...
bool	WriteToCSV (std::string fname, bool appendToFile=false, bool writeColNames=false)
bool	WriteToCSV (const char *fname, bool appendToFile=false, bool writeColNames=false)
void	ClearValidity ()
bool	AddDistinctColumn (unsigned int i)
bool	AddDistinctColumn (std::string col)
bool	AddDistinctColumn (const char *col)
bool	RemoveDistinctColumn (unsigned int i)
bool	RemoveDistinctColumn (std::string col)
bool	RemoveDistinctColumn (const char *col)
bool	AddOrderColumn (unsigned int i)
bool	AddOrderColumn (std::string col)
bool	AddOrderColumn (const char *col)
bool	RemoveOrderColumn (unsigned int i)
bool	RemoveOrderColumn (std::string col)
bool	RemoveOrderColumn (const char *col)
void	SetSelectLimit (int limit)
void	SetSelectOffset (int offset)
void	SetOrderDesc ()
void	SetOrderAsc ()
void	AddExcludeCol (std::string col)
void	ClearExcludedCols ()
bool	GetCurrSeqVal (std::string col, long &iseq)
bool	GetCurrSeqVal (const char *col, long &iseq)
int	GetNPKeyCol ()
const nutools::dbi::ColumnDef *	GetPKeyCol (int i)
void	PrintPQErrorMsg () const
std::string	GetValiditySQL ()
void	SetValiditySQL (std::string cmd)
bool	SetDetector (std::string det)
bool	GetDetector (std::string &det) const
void	SetSchema (std::string s)
std::string	Schema ()
template<class T >
bool	SetValidityRange (std::string cname, T start, T end)
template<class T >
bool	SetValidityRange (std::string cname, T start)
void	RemoveValidityRange (std::string &cname)
void	RemoveValidityRange (const char *cname)
void	PrintColumns ()
bool	GetConnection (int ntry=0)
bool	CloseConnection ()
void	SetConnectionTimeout (int n)
int	GetConnectionTimeout ()
bool	ResetConnectionInfo ()
void	CacheDBCommand (std::string cmd)
void	SetMinTSVld (double t)
void	SetMaxTSVld (double t)
double	GetMaxTSVld () const
double	GetMinTSVld () const
void	SetTag (std::string s)
std::string	GetTag ()
bool	Tag (std::string tn="", bool override=false)
bool	Load ()
bool	Write (bool commit=true)
void	ClearChanRowMap ()
void	FillChanRowMap ()
int	NVldRows (uint64_t channel)
int	NVldChannels ()
std::vector< uint64_t >	VldChannels ()
nutools::dbi::Row *	GetVldRow (uint64_t channel, double t)
std::vector< nutools::dbi::Row * >	GetVldRows (uint64_t channel)
void	SetRecordTime (double t)
void	ClearRecordTime ()
void	EnableFlushCache ()
void	DisableFlushCache ()
void	DisableCache ()
void	EnableCache ()
void	SetWSURL (std::string url)
void	SetQEURL (std::string url)
void	SetTimeQueries (bool f)
void	SetTimeParsing (bool f)
bool	TimeQueries ()
bool	TimeParsing ()
void	SetMinChannel (uint64_t chan)
void	SetMaxChannel (uint64_t chan)
void	SetChannelRange (uint64_t chan1, uint64_t chan2)
void	PrintVMUsed ()
void	PrintPMUsed ()
bool	GetColsFromDB (std::vector< std::string > pkeyList={})
void	SetFolder (std::string f)
std::string	Folder ()

Private Member Functions
bool	LoadConditionsTable ()
bool	LoadUnstructuredConditionsTable ()
bool	LoadNonConditionsTable ()
bool	GetDataFromWebService (Dataset &, std::string)
void	Reset ()
bool	GetConnectionInfo (int ntry=0)
bool	CheckForNulls ()
bool	MakeConditionsCSVString (std::stringstream &ss)
std::string	GetPassword ()
int	ParseSelfStatusLine (char *line)

Private Attributes
bool	addInsertTime
bool	addInsertUser
bool	addUpdateTime
bool	addUpdateUser
bool	fIgnoreEnvVar
bool	fValidityChanged
bool	fDescOrder
bool	fIgnoreDB
bool	fTestedExists
bool	fExistsInDB
bool	fHasConnection
bool	fHasRecordTime
bool	fFlushCache
bool	fDisableCache
bool	fTimeQueries
bool	fTimeParsing
short	fVerbosity
int	fSelectLimit
int	fSelectOffset
int	fConnectionTimeout
int	fTableType
int	fDataTypeMask
int	fDataSource
uint64_t	fMinChannel
uint64_t	fMaxChannel
std::string	fTableName
std::string	fUser
std::string	fRole
std::string	fDBPort
std::string	fDBHost
std::string	fDBName
std::string	fSchema
std::string	fDBCacheFile
std::string	fPassword
std::string	fValiditySQL
std::string	fDetector
std::string	fFolder
std::string	fTag
std::string	fWSURL
std::string	fUConDBURL
std::string	fQEURL
std::vector< nutools::dbi::ColumnDef >	fCol
std::vector< nutools::dbi::Row >	fRow
std::vector< nutools::dbi::ColumnDef >	fValidityStart
std::vector< nutools::dbi::ColumnDef >	fValidityEnd
std::vector< const nutools::dbi::ColumnDef * >	fPKeyList
std::vector< const nutools::dbi::ColumnDef * >	fDistinctCol
std::vector< const nutools::dbi::ColumnDef * >	fOrderCol
std::vector< std::pair< int, int > >	fNullList
std::vector< std::string >	fExcludeCol
std::vector< uint64_t >	fChannelVec
std::unordered_map< uint64_t, std::vector< nutools::dbi::Row * > >	fChanRowMap
PGconn *	fConnection
double	fMaxTSVld
double	fMinTSVld
double	fRecordTime

Friends
std::ostream &	operator<< (std::ostream &stream, const Table &t)

Detailed Description

Database Table Interface

Author

Jonathan Paley

Version

Id

Table.h,v 1.61 2013/02/11 20:48:41 jpaley Exp

Definition at line 47 of file Table.h.

Constructor & Destructor Documentation

nutools::dbi::Table::Table

(

)

Definition at line 36 of file Table.cpp.

References addInsertTime, addInsertUser, addUpdateTime, addUpdateUser, fConnection, fConnectionTimeout, fDataSource, fDataTypeMask, fDBHost, fDBName, fDBPort, fDetector, fExistsInDB, fFolder, fHasConnection, fIgnoreDB, fIgnoreEnvVar, fMaxChannel, fMinChannel, fQEURL, fSchema, fTableName, fTableType, fTag, fTestedExists, fTimeParsing, fTimeQueries, fUConDBURL, fUser, fVerbosity, fWSURL, nutools::dbi::kGenericTable, nutools::dbi::kUnknownSource, and Reset().

                 : fHasRecordTime(false),
                     fFlushCache(false),
                     fDisableCache(false),
                     fMaxTSVld(0),fMinTSVld(0),
                     fRecordTime(0)
    {
      fTableName="";
      fConnection=0;
      fHasConnection=false;
      fDetector="";
      fDBHost="";
      fDBName="";
      fDBPort="";
      fUser="";
      fSchema="undef";
      fTableType = kGenericTable;
      fDataTypeMask = 0;
      fDataSource = kUnknownSource;

      fIgnoreEnvVar = false;
      fTestedExists = false;
      fExistsInDB = false;
      addInsertTime = addUpdateTime = false;
      addInsertUser = addUpdateUser = false;
      fIgnoreDB = false;
      fTimeQueries = true;
      fTimeParsing = true;
      fMinChannel = 0;
      fMaxChannel = 0;
      fFolder = "";
      
      Reset();

      srandom(time(0));

      // default total time to attempt to connect to the db/web server will be 
      // ~4 minutes (some randomness is introduced by libwda)      
      fConnectionTimeout = 4*60; 
      // override default timeout if env. variable is set, but must be 
      // greater than 20 seconds        
      char* tmpStr = getenv("DBITIMEOUT");
      if (tmpStr) {
        int tmpTO = atoi(tmpStr);
        if (tmpTO > 20)
          fConnectionTimeout = tmpTO;
      }

      fTag = "";
      fWSURL = "";
      const char* wsHost = getenv("DBIWSURL");
      if (wsHost) fWSURL = std::string(wsHost);

      fUConDBURL = "";      
      const char* ucondbHost = getenv("DBIUCONDBURL");
      if (ucondbHost) fUConDBURL = std::string(ucondbHost);

      fQEURL = "";
      const char* qeHost = getenv("DBIQEURL");
      if (qeHost) fQEURL = std::string(qeHost);

      fVerbosity=0;
      tmpStr = getenv("DBIVERB");
      if (tmpStr) {
        fVerbosity = atoi(tmpStr);
      }
    }

nutools::dbi::Table::Table	(	std::string	schemaName,
		std::string	tableName,
		int	tableType = kGenericTable,
		std::string	dbhost = "",
		std::string	dbname = "",
		std::string	dbport = "",
		std::string	dbuser = ""
	)

Definition at line 105 of file Table.cpp.

References CloseConnection(), ExistsInDB(), fCol, fConnection, fConnectionTimeout, fDataSource, fDBCacheFile, fExistsInDB, fFolder, fHasConnection, fIgnoreDB, fMaxChannel, fMinChannel, fSchema, fTimeParsing, fTimeQueries, fVerbosity, GetColsFromDB(), GetConnection(), nutools::dbi::kUnknownSource, Name(), Reset(), SetDBHost(), SetDBName(), SetDBPort(), SetTableName(), and SetUser().

    {
      fConnection=0;
      fHasConnection=false;
      std::string errStr;
      fIgnoreDB = false;

      fTimeQueries = true;
      fTimeParsing = true;

      fMinChannel = 0;
      fMaxChannel = 0;

      fFolder = "";
      
      fDataSource = kUnknownSource;

      fVerbosity=0;
      char* tmpStr = getenv("DBIVERB");
      if (tmpStr) {
        fVerbosity = atoi(tmpStr);
      }
      
      // default total time to attempt to connect to the db/web server will be 
      // ~4 minutes (some randomness is introduced by libwda)      
      fConnectionTimeout = 4*60; 
      // override default timeout if env. variable is set, but must be 
      // greater than 20 seconds        
      tmpStr = getenv("DBITIMEOUT");
      if (tmpStr) {
        int tmpTO = atoi(tmpStr);
        if (tmpTO > 20)
          fConnectionTimeout = tmpTO;
      }

      if (!dbname.empty()) SetDBName(dbname);
      /*
      if (DBName() == "") {
        errStr = "Table::Table(): missing database name!";
        throw std::runtime_error(errStr);
      }
      */
      if (!dbhost.empty()) SetDBHost(dbhost);
      /*
      if (DBHost() == "") {
        errStr = "Table::Table(): missing database host!";
        throw std::runtime_error(errStr);
      }
      */

      if (!dbport.empty()) SetDBPort(dbport);
      if (!dbuser.empty()) SetUser(dbuser);
      
      this->SetTableName(tableName);
      fSchema = std::string(schemaName);
      boost::to_lower(fSchema);

      std::string stName = fSchema + std::string(".") + std::string(tableName);
      //      fIgnoreEnvVar = true;

      if (!ExistsInDB()) {
        errStr = "Table::Table(): table \'" + stName + "\' not found in database!";
        throw std::runtime_error(errStr);
      }
      
      Reset();
      fCol.clear();

      bool hasConn = fHasConnection;
      if (! fHasConnection) {
        GetConnection();
        hasConn = false;
      }

      std::vector<std::string> pkeyList;
      // get list of rows that are primary keys
      std::string cmd = "SELECT pg_attribute.attname, format_type(pg_attribute.atttypid, pg_attribute.atttypmod) FROM pg_index, pg_class, pg_attribute WHERE indrelid = pg_class.oid AND pg_attribute.attrelid = pg_class.oid AND pg_attribute.attnum = any(pg_index.indkey) AND indisprimary AND pg_class.oid = '" + stName + "'::regclass";

      PGresult* res = PQexec(fConnection,cmd.c_str());

      if (PQresultStatus(res) != PGRES_TUPLES_OK) {
        errStr = "Table::Table(): command failed: " + std::string(PQerrorMessage(fConnection));
        if (fVerbosity > 0)
          std::cerr << errStr << std::endl;
        PQclear(res);
        CloseConnection();
        throw std::runtime_error(errStr);
      }

      int nRow = PQntuples(res);
      if (nRow == 0) {
        errStr = std::string("Table::Table(): no primary keys defined for table \'") + tableName + std::string("\', unable to proceed.");
        PQclear(res);
        fExistsInDB = false;
        CloseConnection();
        throw std::runtime_error(errStr);
      }

      for (int i=0; i<nRow; ++i) {
        std::string key = std::string(PQgetvalue(res,i,0));
        pkeyList.push_back(key);
      }

      PQclear(res);

      // now get names and types of all columns
      this->GetColsFromDB(pkeyList);

      if (!hasConn) CloseConnection();

      // now set the dB command cache file name
      std::string dirName;
      tmpStr = getenv("DBICACHEDIR");
      if (tmpStr)
        dirName = tmpStr;
      else {
        tmpStr = getenv("PWD");
        if (tmpStr)
          dirName = tmpStr;
        else
          dirName = "/";
      }

      fDBCacheFile = dirName + "/" + "." + Name() + ".cache";

    }

nutools::dbi::Table::~Table

(

)

Definition at line 237 of file Table.cpp.

References Clear(), CloseConnection(), and fHasConnection.

    {
      this->Clear();
      if (fHasConnection) CloseConnection();
    }

Member Function Documentation

int nutools::dbi::Table::AddCol	(	std::string	cname,
		std::string	ctype
	)

Definition at line 333 of file Table.cpp.

References addInsertTime, addInsertUser, addUpdateTime, addUpdateUser, fCol, and Name().

Referenced by ClearRows().

    {
      for (size_t i=0; i<fCol.size(); ++i) {
        if (fCol[i].Name() == cname) {
          std::cerr << "Table::AddCol: column \'" << cname << "\' already exists!  Fatal, aborting..." << std::endl;
          abort();
        }
      }

      ColumnDef cdef(cname,ctype);
      
      fCol.push_back(cdef);
      
      if (cname == "inserttime") addInsertTime = true;
      if (cname == "insertuser") addInsertUser = true;
      if (cname == "updatetime") addUpdateTime = true;
      if (cname == "updateuser") addUpdateUser = true;
      
      return fCol.size()-1;
    }

bool nutools::dbi::Table::AddDistinctColumn

(

unsigned int

i

)

Definition at line 2465 of file Table.cpp.

References fCol, and fDistinctCol.

Referenced by AddDistinctColumn(), and WriteToCSV().

    {
      if (i >= fCol.size()) return false;

      const ColumnDef* c = &fCol[i];
      for (unsigned int j=0; j<fDistinctCol.size(); ++j)
        if (fDistinctCol[j] == c) return true;

      fDistinctCol.push_back(c);

      return true;
    }

bool nutools::dbi::Table::AddDistinctColumn

(

std::string

col

)

Definition at line 2500 of file Table.cpp.

References fDistinctCol, and GetCol().

    {
      const ColumnDef* c = GetCol(cname);

      if (!c) return false;

      for (unsigned int j=0; j<fDistinctCol.size(); ++j)
        if (fDistinctCol[j] == c) return true;

      fDistinctCol.push_back(c);

      return true;
    }

bool nutools::dbi::Table::AddDistinctColumn ( const char *  col )

inline

Definition at line 158 of file Table.h.

References AddDistinctColumn(), and RemoveDistinctColumn().

      { return AddDistinctColumn(std::string(col)); }

void nutools::dbi::Table::AddEmptyRows

(

unsigned int

nrow

)

Definition at line 378 of file Table.cpp.

References fRow, and NewRow().

Referenced by ClearRows(), GetDataFromWebService(), LoadFromCSV(), and LoadFromDB().

    {
      Row* row = this->NewRow();

      fRow.resize(fRow.size()+nrow,*row);
    }

void nutools::dbi::Table::AddExcludeCol ( std::string  col )

inline

Definition at line 180 of file Table.h.

References fExcludeCol.

{fExcludeCol.push_back(col); }

bool nutools::dbi::Table::AddOrderColumn

(

unsigned int

i

)

Definition at line 2537 of file Table.cpp.

References fCol, and fOrderCol.

Referenced by AddOrderColumn(), and RemoveDistinctColumn().

    {
      if (i >= fCol.size()) return false;
      
      const ColumnDef* c = &fCol[i];
      for (unsigned int j=0; j<fOrderCol.size(); ++j)
        if (fOrderCol[j] == c) return true;

      fOrderCol.push_back(c);

      return true;
    }

bool nutools::dbi::Table::AddOrderColumn

(

std::string

col

)

Definition at line 2572 of file Table.cpp.

References fOrderCol, and GetCol().

    {
      const ColumnDef* c = GetCol(cname);

      if (!c) return false;

      for (unsigned int j=0; j<fOrderCol.size(); ++j)
        if (fOrderCol[j] == c) return true;

      fOrderCol.push_back(c);

      return true;
    }

bool nutools::dbi::Table::AddOrderColumn ( const char *  col )

inline

Definition at line 167 of file Table.h.

References AddOrderColumn(), and RemoveOrderColumn().

      { return AddOrderColumn(std::string(col)); }

void nutools::dbi::Table::AddRow

(

const Row *

row

)

Definition at line 356 of file Table.cpp.

References nutools::dbi::Row::Col(), fCol, fNullList, fRow, nutools::dbi::Column::IsNull(), and Name().

Referenced by AddRow(), and ClearRows().

    {
      if (!row) return;

      Row r2(*row);

      for (unsigned int i=0; i<fCol.size(); ++i) {
        if (fCol[i].Name() == "inserttime" ||
            fCol[i].Name() == "insertuser" ||
            fCol[i].Name() == "updatetime" ||
            fCol[i].Name() == "updateuser" ) continue;
        if (!fCol[i].CanBeNull())
          if (r2.Col(i).IsNull())
            fNullList.push_back(std::pair<int,int>(fRow.size(),i));
      }

      fRow.push_back(r2);

    }

void nutools::dbi::Table::AddRow

(

const Row &

row

)

Definition at line 386 of file Table.cpp.

References AddRow().

    {
      AddRow(&row);
    }

void nutools::dbi::Table::CacheDBCommand

(

std::string

cmd

)

Definition at line 438 of file Table.cpp.

References fDBCacheFile.

Referenced by GetConnectionTimeout(), and WriteToDB().

    {
      std::ofstream fout;
      fout.open(fDBCacheFile.c_str(),std::ios_base::app);

      fout << cmd << std::endl;

      fout.close();
    }

bool nutools::dbi::Table::CheckForNulls ( )

private

Definition at line 422 of file Table.cpp.

References fCol, fNullList, and fVerbosity.

Referenced by Folder(), WriteToCSV(), and WriteToDB().

    {
      bool isOk = fNullList.empty();

      if (!isOk) // print out list of null columns
        for (unsigned int i=0; i<fNullList.size(); ++i)
          if (fVerbosity>0)
            std::cerr << fCol[fNullList[i].second].Name() << " is NULL in row "
                      << fNullList[i].first << std::endl;

      return isOk;

    }

void nutools::dbi::Table::Clear ( )

inline

Definition at line 105 of file Table.h.

References fDistinctCol, fNullList, fOrderCol, fRow, fValidityChanged, fValidityEnd, fValiditySQL, and fValidityStart.

Referenced by ~Table().

                   {
        fRow.clear(); fValidityStart.clear(); fValidityEnd.clear();
        fOrderCol.clear(); fDistinctCol.clear(); fNullList.clear();
        fValiditySQL = "";
        fValidityChanged = true;
      }

void nutools::dbi::Table::ClearChanRowMap ( )

inline

Definition at line 284 of file Table.h.

References fChanRowMap, and FillChanRowMap().

{ fChanRowMap.clear(); }

void nutools::dbi::Table::ClearExcludedCols ( )

inline

Definition at line 181 of file Table.h.

References fExcludeCol, and GetCurrSeqVal().

{ fExcludeCol.clear(); }

void nutools::dbi::Table::ClearPassword ( )

inline

Definition at line 95 of file Table.h.

References fPassword.

{ fPassword=""; }

void nutools::dbi::Table::ClearRecordTime ( )

inline

Definition at line 294 of file Table.h.

References fHasRecordTime.

{ fHasRecordTime = false;}

void nutools::dbi::Table::ClearRows ( )

inline

Definition at line 112 of file Table.h.

References AddCol(), AddEmptyRows(), AddRow(), fNullList, fRow, fValidityChanged, GetRow(), and RemoveRow().

{ fRow.clear(); fNullList.clear(); fValidityChanged=true;}

void nutools::dbi::Table::ClearValidity

(

)

Definition at line 484 of file Table.cpp.

References fValidityChanged, fValidityEnd, fValiditySQL, and fValidityStart.

Referenced by Reset(), and WriteToCSV().

    {
      fValidityStart.clear();
      fValidityEnd.clear();
      fValiditySQL = "";
      fValidityChanged=true;
    }

bool nutools::dbi::Table::CloseConnection

(

)

Definition at line 837 of file Table.cpp.

References fConnection, fHasConnection, and fVerbosity.

Referenced by ExecuteSQL(), ExistsInDB(), GetColsFromDB(), GetConnection(), GetCurrSeqVal(), LoadFromDB(), RemoveValidityRange(), Table(), WriteToDB(), and ~Table().

    {
      if (fConnection) {
        PQfinish(fConnection);
        if (fVerbosity > 0)
          std::cout << "Closed connection" << std::endl;
      }

      fConnection = 0;
      fHasConnection = false;

      return true;
    }

int nutools::dbi::Table::DataSource ( )

inline

Definition at line 66 of file Table.h.

References fDataSource.

{ return fDataSource; }

int nutools::dbi::Table::DataTypeMask ( )

inline

Definition at line 67 of file Table.h.

References fDataTypeMask, SetDataSource(), SetTableName(), and SetTableType().

{ return fDataTypeMask; }

std::string nutools::dbi::Table::DBHost ( )

inline

Definition at line 61 of file Table.h.

References fDBHost.

{ return fDBHost;}

std::string nutools::dbi::Table::DBName ( )

inline

Definition at line 60 of file Table.h.

References fDBName.

{ return fDBName;}

std::string nutools::dbi::Table::DBPort ( )

inline

Definition at line 64 of file Table.h.

References fDBPort.

{ return fDBPort; }

void nutools::dbi::Table::DisableCache ( )

inline

Definition at line 299 of file Table.h.

References fDisableCache.

{ fDisableCache = true; }

void nutools::dbi::Table::DisableFlushCache ( )

inline

Definition at line 297 of file Table.h.

References fFlushCache.

{ fFlushCache = false; }

void nutools::dbi::Table::DisablePasswordAccess ( )

inline

Definition at line 96 of file Table.h.

References fPassword.

{ fPassword = ""; }

void nutools::dbi::Table::EnableCache ( )

inline

Definition at line 300 of file Table.h.

References fDisableCache.

{ fDisableCache = false; }

void nutools::dbi::Table::EnableFlushCache ( )

inline

Definition at line 296 of file Table.h.

References fFlushCache.

{ fFlushCache = true; }

bool nutools::dbi::Table::ExecuteSQL	(	std::string	cmd,
		PGresult *&	res
	)

Definition at line 1030 of file Table.cpp.

References CloseConnection(), fConnection, fHasConnection, fIgnoreDB, fTimeQueries, fVerbosity, and GetConnection().

Referenced by GetCol().

    {
      if (fIgnoreDB) return false;

      bool hasConn = fHasConnection;
      if (! fHasConnection) {
        GetConnection();
        hasConn = false;
      }

      if (!fConnection) {
        std::cerr << "Table::ExecuteSQL: No connection to the database!" << std::endl;
        return false;
      }

      if (cmd == "") return false;

      if (fVerbosity)
        std::cerr << "Executing SQL query: " << cmd << std::endl;

      boost::posix_time::ptime ctt1;
      boost::posix_time::ptime ctt2;
    
      if (fTimeQueries) {
        ctt1 = boost::posix_time::microsec_clock::local_time();
      }

      res = PQexec(fConnection,cmd.c_str());
      if (fTimeQueries) {
        ctt2 = boost::posix_time::microsec_clock::local_time();
        boost::posix_time::time_duration tdiff = ctt2 - ctt1;
        std::cerr << "Table::ExecuteSQL(" << cmd << "): query took " 
                  << tdiff.total_milliseconds() << " ms" << std::endl;
      }
      
      // close connection to the dB if necessary
      if (! hasConn) CloseConnection();

      return (res != 0);
    }

bool nutools::dbi::Table::ExistsInDB

(

)

Definition at line 893 of file Table.cpp.

References CloseConnection(), fConnection, fExistsInDB, fHasConnection, fIgnoreDB, fSchema, fTableType, fTestedExists, fVerbosity, GetConnection(), nutools::dbi::kConditionsTable, and Name().

Referenced by GetCol(), LoadFromDB(), Table(), and WriteToDB().

    {
      if (fIgnoreDB) return false;

      if (fTestedExists) return fExistsInDB;

      std::string tname = this->Name();

      fTestedExists = true;

      bool hasConn = fHasConnection;
      if (! fHasConnection) {
        GetConnection();
        hasConn = false;
      }

      std::string cmd = "SELECT tablename FROM pg_tables WHERE schemaname=\'" +
        fSchema + "\'";
      //  std::cout << tname << ": " << cmd << std::endl;
      PGresult* res = PQexec(fConnection,cmd.c_str());

      if (PQresultStatus(res) != PGRES_TUPLES_OK) {
        if (fVerbosity > 0)
          std::cerr << "Table::ExistsInDB command failed: "
                    << PQerrorMessage(fConnection) << std::endl;
        PQclear(res);
        fExistsInDB = false;  // set this to false just in case
        CloseConnection();
        return false;
      }

      bool retVal = false;
      int nRow = PQntuples(res);

      int tc=0;
      std::vector<std::string> tList;
      tList.push_back(tname+std::string("_snapshot"));
      tList.push_back(tname+std::string("_snapshot_data"));
      tList.push_back(tname+std::string("_tag"));
      tList.push_back(tname+std::string("_tag_snapshot"));
      tList.push_back(tname+std::string("_update"));

      for (int i=0; i<nRow; ++i) {
        //    std::cout << string(PQgetvalue(res,i,0)) << std::endl;
        std::string tStr = std::string(PQgetvalue(res,i,0));

        if (fTableType != kConditionsTable) {
          if (tStr == tname) {
            retVal = true;
            break;
          }
        }
        else {
          if (std::string(PQgetvalue(res,i,0)) == tList[0] ||
              std::string(PQgetvalue(res,i,0)) == tList[1] ||
              std::string(PQgetvalue(res,i,0)) == tList[2] ||
              std::string(PQgetvalue(res,i,0)) == tList[3] ||
              std::string(PQgetvalue(res,i,0)) == tList[4] )
            ++tc;

          if (tc == 5) {
            retVal = true;
            break;
          }
        }
      }

      PQclear(res);

      if (!hasConn) CloseConnection();

      fExistsInDB = true;
      return retVal;

    }

void nutools::dbi::Table::FillChanRowMap

(

)

Definition at line 1989 of file Table.cpp.

References util::begin(), nutools::dbi::Row::Channel(), util::empty(), fChannelVec, fChanRowMap, GetRow(), NRow(), and nutools::dbi::Row::VldTime().

Referenced by ClearChanRowMap().

    {
      nutools::dbi::Row* row;
      uint64_t chan;
      double tv;
      fChanRowMap.clear();

      for (int i=0; i<this->NRow(); ++i) {
        row = this->GetRow(i);
        chan = row->Channel();
        tv = row->VldTime();
        if (fChanRowMap[chan].empty())
          fChanRowMap[chan].push_back(row);
        else {
          bool wasInserted=false;
          for (unsigned int j=0; j<fChanRowMap[chan].size(); ++j) {
            if (tv < fChanRowMap[chan][j]->VldTime()) {
              fChanRowMap[chan].insert(fChanRowMap[chan].begin()+j,row);
              wasInserted=true;
              break;
            }
          }
          if (!wasInserted)
            fChanRowMap[chan].push_back(row);
        }
      }

      fChannelVec.clear();
      std::unordered_map<uint64_t,std::vector<nutools::dbi::Row*> >::iterator itr = fChanRowMap.begin();
      std::unordered_map<uint64_t,std::vector<nutools::dbi::Row*> >::iterator itrEnd = fChanRowMap.end();

      for (; itr != itrEnd; ++itr) 
        fChannelVec.push_back(itr->first);


    }

std::string nutools::dbi::Table::Folder ( )

inline

Definition at line 321 of file Table.h.

References CheckForNulls(), fFolder, GetConnectionInfo(), GetDataFromWebService(), GetPassword(), LoadConditionsTable(), LoadNonConditionsTable(), LoadUnstructuredConditionsTable(), MakeConditionsCSVString(), ParseSelfStatusLine(), and Reset().

Referenced by LoadUnstructuredConditionsTable().

{ return fFolder; }

const nutools::dbi::ColumnDef* nutools::dbi::Table::GetCol ( int  i )

inline

Definition at line 133 of file Table.h.

References fCol.

Referenced by AddDistinctColumn(), AddOrderColumn(), GetCol(), LoadConditionsTable(), LoadNonConditionsTable(), MakeConditionsCSVString(), PrintColumns(), RemoveDistinctColumn(), RemoveOrderColumn(), and SetValidityRange().

{return &fCol[i]; }

const nutools::dbi::ColumnDef * nutools::dbi::Table::GetCol

(

std::string &

cname

)

Definition at line 577 of file Table.cpp.

References fCol, and Name().

    {
      unsigned int i=0;
      for ( ; i < fCol.size(); ++i)
        if (fCol[i].Name() == cname) break;

      if (i >= fCol.size()) return 0;

      return &fCol[i];
    }

const nutools::dbi::ColumnDef* nutools::dbi::Table::GetCol ( const char *  cname )

inline

Definition at line 135 of file Table.h.

References ExecuteSQL(), ExistsInDB(), GetCol(), LoadFromCSV(), SetTolerance(), and Tolerance().

        { std::string cstr(cname); return GetCol(cstr); }

int nutools::dbi::Table::GetColIndex

(

std::string

cname

)

Definition at line 589 of file Table.cpp.

References fCol, and Name().

Referenced by GetColName().

    {
      for (unsigned int i=0; i<fCol.size(); ++i)
        if (fCol[i].Name() == cname) return (int)i;
      std::cerr << "No such column \"" << cname << "\". Returning -1" << std::endl;
      return -1;
    }

std::string nutools::dbi::Table::GetColName ( int  i )

inline

Definition at line 130 of file Table.h.

References fCol, and GetColIndex().

{return fCol[i].Name(); }

std::vector< std::string > nutools::dbi::Table::GetColNames

(

)

Definition at line 608 of file Table.cpp.

References fCol.

Referenced by NewRow().

    {
      std::vector<std::string> nameList;

      for (unsigned int i=0; i<fCol.size(); ++i)
        nameList.push_back(fCol[i].Name());

      return nameList;
    }

std::map< std::string, int > nutools::dbi::Table::GetColNameToIndexMap

(

)

Definition at line 598 of file Table.cpp.

References fCol.

Referenced by NewRow(), and WriteToDB().

    {
      std::map<std::string,int> tmap;
      for (unsigned int i=0; i<fCol.size(); ++i) {
        tmap[fCol[i].Name()] = int(i);
      }
      return tmap;
    }

bool nutools::dbi::Table::GetColsFromDB

(

std::vector< std::string >

pkeyList = {}

)

Definition at line 245 of file Table.cpp.

References addInsertTime, addInsertUser, addUpdateTime, addUpdateUser, CloseConnection(), fCol, fConnection, fExistsInDB, fHasConnection, fSchema, fTableName, fTableType, fVerbosity, GetConnection(), nutools::dbi::kConditionsTable, nutools::dbi::kUnstructuredConditionsTable, and nutools::dbi::ColumnDef::SetCanBeNull().

Referenced by main(), SetChannelRange(), and Table().

    {
      if (fTableType == kUnstructuredConditionsTable) {
        std::cerr << "Table::GetColsFromDB() currently disabled for unstructured conditions tables." << std::endl;
        abort();
      }
      
      bool hasConn = fHasConnection;
      if (! fHasConnection) {
        GetConnection();
        hasConn = false;
      }
      
      // now get names and types of all columns
      std::string cmd = "SELECT column_name, data_type from information_schema.columns where table_name = \'" + std::string(fTableName);
      if (fTableType == kConditionsTable)
        cmd += "_update";
      cmd += "\' and table_schema=\'" + fSchema + "\'";

      PGresult* res = PQexec(fConnection,cmd.c_str());

      if (PQresultStatus(res) != PGRES_TUPLES_OK) {
        std::string errStr = "Table::Table() command failed: " + std::string(PQerrorMessage(fConnection));
        if (fVerbosity > 0)
          std::cerr << errStr << std::endl;
        PQclear(res);
        fExistsInDB = false;  // set this to false just in case
        CloseConnection();
        throw std::runtime_error(errStr);
      }

      int nRow = PQntuples(res);

      for (int i=0; i<nRow; ++i) {      
        std::string cname = std::string(PQgetvalue(res,i,0));
        std::string ctype = std::string(PQgetvalue(res,i,1));

        if (fTableType == kConditionsTable) {     
          if (cname == "__snapshot_id") continue;
          if (cname == "__tr") continue;
          if (cname == "__channel") continue; //cname = "channel";
          if (cname == "__tv") continue; //cname = "tv";
        }
        
        if (ctype == "smallint") ctype="short";
        else if (ctype == "double precision") ctype="double";
        else if (ctype == "boolean") ctype="bool";
        else if (ctype == "timestamp without time zone") ctype="timestamp";
        else if (ctype.substr(0,7) == "varchar" || ctype == "text")
          ctype = "text"; //varchar" + ctype.substr(8,ctype.find(')')-1);
        
        // check if this column is "auto_incr", only if !conditions table
        if (fTableType != kConditionsTable && ctype == "integer") {
          std::string stName = fSchema + std::string(".") + std::string(fTableName);
          cmd = "SELECT pg_get_serial_sequence(\'" + stName +
            "\',\'" + cname + "\')";
          PGresult* res2 = PQexec(fConnection,cmd.c_str());
          int nRow2 = PQntuples(res2);
          for (int j=0; j<nRow2; ++j) {
            std::string tStr = std::string(PQgetvalue(res2,j,0));
            if (tStr != "") ctype = "auto_incr";
          }
          PQclear(res2);
        }
        
        // now create Column based on this info
        ColumnDef cdef(cname,ctype);

        if (find(pkeyList.begin(),pkeyList.end(),cname) != pkeyList.end()) {
          cdef.SetCanBeNull(false);
        }
        fCol.insert(fCol.begin(),cdef);

        if (cname == "inserttime") addInsertTime = true;
        if (cname == "insertuser") addInsertUser = true;
        if (cname == "updatetime") addUpdateTime = true;
        if (cname == "updateuser") addUpdateUser = true;
      }

      PQclear(res);

      if (!hasConn) CloseConnection();

      return true;
    }

bool nutools::dbi::Table::GetConnection

(

int

ntry = 0

)

Definition at line 759 of file Table.cpp.

References CloseConnection(), e, fConnection, fConnectionTimeout, fDBHost, fDBName, fDBPort, fHasConnection, fIgnoreDB, fPassword, fUser, fVerbosity, GetConnectionInfo(), nutools::dbi::Util::RunningOnGrid(), SetPasswordFile(), and t1.

Referenced by ExecuteSQL(), ExistsInDB(), GetColsFromDB(), GetCurrSeqVal(), LoadFromDB(), RemoveValidityRange(), Table(), and WriteToDB().

    {
      if (fIgnoreDB) return false;

      bool gotConnInfo = false;
      try {
        gotConnInfo = GetConnectionInfo(ntry);
      }
      catch (std::runtime_error& e) {
        std::cerr << e.what() << std::endl;
        return false;
      }

      if (!gotConnInfo) return false;

      // now get the password file name for read-only access

      if (Util::RunningOnGrid()) {
        char* tmpStr = getenv("DBIGRIDPWDFILE");
        if(tmpStr){
          if(!this->SetPasswordFile(tmpStr)){
            return false;
          }
        }       
      }
      else {    
        char* tmpStr = getenv("DBIPWDFILE");
        if(tmpStr){
          if(!this->SetPasswordFile(tmpStr)) {
            return false;
          }
        }
      }

      if (!fConnection) {
        std::string cmd = "dbname = " + fDBName + " host = " + fDBHost + " user = " + fUser;
        if (fDBPort != "")
          cmd += " port = " + fDBPort;

        if (fPassword != "")
          cmd += " password = " + fPassword;

        fConnection = PQconnectdb(cmd.c_str());

        int nTry=0;
        int sleepTime = 2;
        time_t t0 = time(NULL);
        time_t t1 = t0;

        while (PQstatus(fConnection) != CONNECTION_OK &&
               ((t1-t0) < fConnectionTimeout) ) { 
          std::cerr << "Connection to " << fDBHost << ":"
                    << fDBName << " failed: "
                    << PQerrorMessage(fConnection) << std::endl;
          
          CloseConnection();      
          sleepTime = 1 + ((double)random()/(double)RAND_MAX)*(1 << nTry++);
          sleep(sleepTime);
          t1 = time(NULL);
          fConnection = PQconnectdb(cmd.c_str());
        }
        if (PQstatus(fConnection) != CONNECTION_OK) {
          CloseConnection();
          if (! GetConnection(ntry+1)) {
            std::cerr << "Too many attempts to connect to the database, " 
                      << ", giving up." << std::endl;
            CloseConnection();
            return false;
          }
        }
        fHasConnection = true;
        if (fVerbosity > 0)
          std::cout << "Got new connection" << std::endl;
      }
      
      return true;
    }

bool nutools::dbi::Table::GetConnectionInfo ( int  ntry = 0 )

private

Definition at line 699 of file Table.cpp.

References fDBHost, fDBName, fDBPort, fIgnoreEnvVar, and fUser.

Referenced by Folder(), GetConnection(), and WriteToDB().

    {
      char* tmpStr;
      char hname[256];

      if (!fIgnoreEnvVar) {
        // now check environment variables, which will override any previous settings
        if (ntry == 0) {
          tmpStr = getenv("DBIHOST");
          if (tmpStr)
            fDBHost = tmpStr;
        }
        else {
          sprintf(hname,"DBIHOST%d",ntry);
          tmpStr = getenv(hname);           
          if (tmpStr) {
            std::cerr << "Switching to " << tmpStr << std::endl;
            fDBHost = tmpStr;
          }
          else 
            return false;
        }
        
        tmpStr = getenv("DBINAME");
        if (tmpStr)
          fDBName = tmpStr;
        tmpStr = getenv("DBIPORT");
        if (tmpStr)
          fDBPort = tmpStr;
        tmpStr = getenv("DBIUSER");
        if (tmpStr)
          fUser = tmpStr;
      }

      if (fUser == "") {
        tmpStr = getenv("USER");
        if (tmpStr) {
          fUser = tmpStr;
          std::cerr << "Table::GetConnectionInfo: DB User undefined.  Setting to \""
                    << fUser << "\"" << std::endl;
        }       
        else {
          throw std::runtime_error("Table::GetConnectionInfo: DB USER undefined.");
        }
        
      }
      if (fDBHost == "") {
        throw std::runtime_error("Table::GetConnectionInfo: DB HOST undefined.");
      }
      if (fDBName == "") {
        throw std::runtime_error("Table::GetConnectionInfo: DB NAME undefined.");
      }

      /*      if (fDBPort == "")
        if (fTable->hasDbPort())
          fDBPort = fTable->getDbPort();
      */
      return true;
    }

int nutools::dbi::Table::GetConnectionTimeout ( )

inline

Definition at line 264 of file Table.h.

References CacheDBCommand(), fConnectionTimeout, operator<<, and ResetConnectionInfo().

{ return fConnectionTimeout; }

bool nutools::dbi::Table::GetCurrSeqVal	(	std::string	col,
		long &	iseq
	)

Definition at line 970 of file Table.cpp.

References CloseConnection(), fConnection, fHasConnection, fIgnoreDB, fVerbosity, GetConnection(), Name(), and Schema().

Referenced by ClearExcludedCols(), GetCurrSeqVal(), and WriteToDB().

    {
      if (fIgnoreDB) return false;

      bool hasConn = fHasConnection;
      if (! fHasConnection) {
        GetConnection();
        hasConn = false;
      }

      // now get current sequence value:

      std::string cmd = "SELECT last_value FROM ";
      cmd += Schema() + "." + Name();
      cmd += "_" + col + "_seq";

      if (fVerbosity > 0)
        std::cerr << "Table::GetCurrSeqVal: Executing PGSQL command: \n\t"
                  << cmd << std::endl;

      PGresult* res = PQexec(fConnection, cmd.c_str());
      if (PQresultStatus(res) != PGRES_TUPLES_OK) {
        if (fVerbosity > 0)
          std::cerr << "SELECT failed: " << PQerrorMessage(fConnection) << std::endl;
        PQclear(res);
        return false;
      }

      // check that the number of columns is consistent
      if (PQnfields(res) != 1) {
        PQclear(res);
        return false;
      }

      // now cache rows
      int nRow = PQntuples(res);

      if (nRow != 1) {
        PQclear(res);
        return false;
      }

      if (! PQgetisnull(res,0,0)) {
        std::string vstr = PQgetvalue(res,0,0);
        try {
          iseq = boost::lexical_cast<long>(vstr);
        }
        catch (boost::bad_lexical_cast &) {
          PQclear(res);
          return false;
        }
      }

      PQclear(res);

      if (!hasConn) CloseConnection();

      return true;
    }

bool nutools::dbi::Table::GetCurrSeqVal ( const char *  col, long &  iseq  )

inline

Definition at line 184 of file Table.h.

References GetCurrSeqVal().

      { return GetCurrSeqVal(std::string(col), iseq); }

bool nutools::dbi::Table::GetDataFromWebService ( Dataset &  ds, std::string  myss  )

private

Definition at line 1572 of file Table.cpp.

References AddEmptyRows(), fCol, fConnectionTimeout, fRow, fTimeParsing, fTimeQueries, fVerbosity, Name(), and t1.

Referenced by Folder(), LoadConditionsTable(), and LoadNonConditionsTable().

    {
      Tuple tu;
      char ss[1024]; 
      char ss2[1024]; 
      int wda_err, err;
      std::vector<int> colMap(fCol.size());
      std::vector<bool> isString(fCol.size());
      std::vector<bool> isKnownField(fCol.size());
      
      const char* uagent = NULL;

      if(fVerbosity > 0)
        std::cout << "DBWeb query: " << myss << std::endl;
      
      boost::posix_time::ptime ctt1;
      boost::posix_time::ptime ctt2;
      
      if (fTimeQueries) {
        ctt1 = boost::posix_time::microsec_clock::local_time();
      }
      
      ds = getDataWithTimeout(myss.c_str(), uagent, 
                              fConnectionTimeout, &wda_err);
      
      if (fTimeQueries) {
        ctt2 = boost::posix_time::microsec_clock::local_time();
        boost::posix_time::time_duration tdiff = ctt2 - ctt1;
        std::cerr << "Table::Load(" << Name() << "): query took " 
                  << tdiff.total_milliseconds() << " ms" << std::endl;
      }

      int httpStatus = getHTTPstatus(ds);

      if (httpStatus == 504) {
        int nTry=0;
        int sleepTime = 2;
        time_t t0 = time(NULL);
        time_t t1 = t0;

        while (httpStatus == 504 && ((t1-t0) < fConnectionTimeout) ) { 
          sleepTime = 1 + ((double)random()/(double)RAND_MAX)*(1 << nTry++);

          std::cerr << "Table::Load() for " << Name() 
                    << " failed with error 504, retrying in " << sleepTime 
                    << " seconds." << std::endl;
          
          sleep(sleepTime);
          t1 = time(NULL);
          if (fTimeQueries) 
            ctt1 = boost::posix_time::microsec_clock::local_time();
          
          ds = getDataWithTimeout(myss.c_str(), uagent,
                                  fConnectionTimeout, &wda_err);
          
          if (fTimeQueries) {
            ctt2 = boost::posix_time::microsec_clock::local_time();
            boost::posix_time::time_duration tdiff = ctt2 - ctt1;
            std::cerr << "Table::Load(" << Name() << "): query took " 
                      << tdiff.total_milliseconds() << " ms" << std::endl;
          }
          httpStatus = getHTTPstatus(ds);
        }
      }

      if (httpStatus != 200) {
        std::cerr << "Table::Load: Web Service returned HTTP status " 
                  << httpStatus << ": " << getHTTPmessage(ds) << std::endl;
        return false;
      }

      if (fTimeParsing)
        ctt1 = boost::posix_time::microsec_clock::local_time();

      int ntup = getNtuples(ds);

      // Getting no rows back can be legitimate
      if(ntup == 0){
        if(fVerbosity > 0)
          std::cout << "Got zero rows from database. Is that expected?" << std::endl;

        fRow.clear();

        return true;
      }

      if(fVerbosity > 0)
        std::cout << "Got " << ntup-1 << " rows from database" << std::endl;

      int ioff=fRow.size();

      AddEmptyRows(ntup);

      tu = getFirstTuple(ds);
      if (tu == NULL) {
        std::cerr << "Table::Load(" << Name() << ") has NULL first tuple!"
                  << std::endl;
        return false;
      }
      int ncol2 = getNfields(tu);
      std::string chanStr = "channel";
      std::string tvStr = "tv";
      std::string tvEndStr = "tvend";
      int chanIdx=-1;
      int tvIdx=-1;
      int tvEndIdx=-1;
      for (int i=0; i<ncol2; ++i) {
        getStringValue(tu,i,ss,sizeof(ss),&err);
        if (chanStr == ss)  { chanIdx=i;  continue;}
        if (tvStr == ss)    { tvIdx=i;    continue;}
        if (tvEndStr == ss) { tvEndIdx=i; continue;}

        bool foundMatch=false;
        for (unsigned int icol=0; icol<fCol.size(); ++icol) {
          if (fCol[icol].Name() == ss) {
            colMap[i] = icol;
            isString[i] = false;
            if (fCol[icol].Type() == "string" || fCol[icol].Type() == "text")
              isString[i] = true;
            foundMatch=true;
            break;
          }
        }
        if (!foundMatch) // this means this field was unexpected, so
                         // ignore it downstream
          isKnownField[i] = false;
        else
          isKnownField[i] = true;         
      }
      
      releaseTuple(tu);
      tu = getNextTuple(ds);
      int irow=0;
      while (tu != NULL) {
        for (int i=0; i<ncol2; ++i) {     
          getStringValue(tu,i,ss,sizeof(ss),&err);
          if (i == chanIdx) {
            uint64_t chan = strtoull(ss,NULL,10);
            fRow[ioff+irow].SetChannel(chan);
            continue;
          }
          else if (i == tvIdx) {
            double t1 = strtod(ss,NULL);
            fRow[ioff+irow].SetVldTime(t1);
          }
          else if (i == tvEndIdx) {
            double t1 = strtod(ss,NULL);
            fRow[ioff+irow].SetVldTimeEnd(t1);      
          }
          else {
            if (isKnownField[i]) {
              if (isString[i] && (ss[0]=='\'' || ss[0]=='\"')) { // remove quotes
                int k = strlen(ss);
                strncpy(ss2,&ss[1],k-2);
                ss2[k-2] = '\0';
                fRow[ioff+irow].Col(colMap[i]).FastSet(ss2);
              }
              else
                fRow[ioff+irow].Col(colMap[i]).FastSet(ss);
            }
          }
        }
        releaseTuple(tu);
        tu = getNextTuple(ds);
        ++irow;
      };

      if (fTimeParsing) {
        ctt2 = boost::posix_time::microsec_clock::local_time();
        boost::posix_time::time_duration tdiff = ctt2 - ctt1;
        std::cerr << "Table::Load(" << Name() << "): parsing took " 
                  << tdiff.total_milliseconds() << " ms" << std::endl;
      }

      // Make sure that the rows list is no longer than what we actually
      // filled. This happens because ntup above included the header row that
      // gives the column names.
      while(int(fRow.size()) > irow) fRow.pop_back();
        
      releaseDataset(ds);

      return true;
    }

bool nutools::dbi::Table::GetDetector

(

std::string &

det

)

const

Definition at line 515 of file Table.cpp.

References fDetector.

Referenced by SetValiditySQL().

    {
      if (fDetector == "") return false;
      det = fDetector;

      return true;
    }

double nutools::dbi::Table::GetMaxTSVld ( ) const

inline

Definition at line 274 of file Table.h.

References fMaxTSVld.

{return fMaxTSVld; }

double nutools::dbi::Table::GetMinTSVld ( ) const

inline

Definition at line 275 of file Table.h.

References fMinTSVld.

{return fMinTSVld; }

int nutools::dbi::Table::GetNPKeyCol ( )

inline

Definition at line 189 of file Table.h.

References fPKeyList.

{ return fPKeyList.size(); }

std::string nutools::dbi::Table::GetPassword ( )

private

Definition at line 2606 of file Table.cpp.

References fin.

Referenced by Folder(), Tag(), and Write().

    {
      std::string pwd = "";

      char* pwdFile = getenv("DBIWSPWDFILE");
      if (pwdFile) {
        std::ifstream fin;
        fin.open(pwdFile);
        if (!fin.is_open() || !fin.good()) {
          std::cerr << "Could not open password file " << pwdFile
                    << ".  Canceling Table::Write()" << std::endl;
          return pwd;
        }
        else {
          fin >> pwd;
          fin.close();
        }
      }

      return pwd;
    }

const nutools::dbi::ColumnDef* nutools::dbi::Table::GetPKeyCol ( int  i )

inline

Definition at line 190 of file Table.h.

References fPKeyList, and PrintPQErrorMsg().

{ return fPKeyList[i]; }

Row *const nutools::dbi::Table::GetRow

(

int

i

)

Definition at line 413 of file Table.cpp.

References fRow.

Referenced by ClearRows(), FillChanRowMap(), and MakeConditionsCSVString().

    {
      if (i >= 0 && i < (int)fRow.size())
        return &fRow[i];
      else
        return 0;
    }

std::string nutools::dbi::Table::GetTag ( )

inline

Definition at line 278 of file Table.h.

References fTag, Load(), Tag(), and Write().

{ return fTag; }

std::string nutools::dbi::Table::GetValiditySQL ( )

inline

Definition at line 208 of file Table.h.

References fValiditySQL.

{ return fValiditySQL; }

nutools::dbi::Row * nutools::dbi::Table::GetVldRow	(	uint64_t	channel,
		double	t
	)

Definition at line 2035 of file Table.cpp.

References fChanRowMap.

Referenced by VldChannels().

    {      
      std::vector<nutools::dbi::Row*>& rlist = fChanRowMap[channel];
      if (rlist.empty()) return 0;
      int irow=-1;
      double tv;
      // fChanRowMap is time-ordered, so this simplifies things
      unsigned int i=0;
      for ( ; i<rlist.size(); ++i) {
        tv = rlist[i]->VldTime();
        if (t >= tv) irow=i;
        else break;
      }
      if (irow>=0) return rlist[irow];
      return 0;
    }

std::vector< nutools::dbi::Row * > nutools::dbi::Table::GetVldRows

(

uint64_t

channel

)

Definition at line 2028 of file Table.cpp.

References fChanRowMap.

Referenced by VldChannels().

    {
      return fChanRowMap[channel];
    }

bool nutools::dbi::Table::Load

(

)

Definition at line 1971 of file Table.cpp.

References fConnectionTimeout, fTableType, nutools::dbi::kConditionsTable, nutools::dbi::kUnstructuredConditionsTable, LoadConditionsTable(), LoadNonConditionsTable(), LoadUnstructuredConditionsTable(), and nutools::dbi::Util::RunningOnGrid().

Referenced by GetTag(), and main().

    {      
      if (Util::RunningOnGrid()) {
        fConnectionTimeout = 1800;
      }
      if (fTableType==kConditionsTable) 
        return LoadConditionsTable();
      else if (fTableType==kUnstructuredConditionsTable) 
        return LoadUnstructuredConditionsTable();
      else
        return LoadNonConditionsTable();
    }

bool nutools::dbi::Table::LoadConditionsTable ( )

private

Definition at line 1880 of file Table.cpp.

References fDataTypeMask, fDisableCache, fExcludeCol, fFlushCache, fHasRecordTime, fMaxChannel, fMaxTSVld, fMinChannel, fMinTSVld, fRecordTime, fTag, fValiditySQL, fWSURL, GetCol(), GetDataFromWebService(), nutools::dbi::kDataOnly, nutools::dbi::kMCOnly, nutools::dbi::kNone, nutools::dbi::ColumnDef::Name(), Name(), NCol(), nutools::dbi::Util::RunningOnGrid(), and Schema().

Referenced by Folder(), and Load().

    {
      if (fDataTypeMask == 0) {
        std::cerr << "Table::LoadConditionsTable: Data type mask is not set!" << std::endl;
        return false;
      }

      if (fMinTSVld == 0 || fMaxTSVld == 0) {
        std::cerr << "Table::LoadConditionsTable: No validity time is set!" << std::endl;
        return false;
      }

      if (fWSURL == "") {
        std::cerr << "Table::LoadConditionsTable: Web Service URL is not set!" << std::endl;
        return false;
      }

      if (!Util::RunningOnGrid()) {
        std::string interactiveURL = getenv("DBIWSURLINT");
        if (!interactiveURL.empty())
          fWSURL = interactiveURL;
      }

      int ncol = this->NCol();

      std::stringstream myss;

      myss << fWSURL << "get?table=" << Schema() << "." << Name() << "&";

      if (fDataTypeMask > kNone) {
        myss << "type=";
        
        if ((fDataTypeMask & kMCOnly)) myss << "mc";
        if ((fDataTypeMask & kDataOnly)) myss << "data";
      
        myss << "&";
      }
      
      if (fMaxChannel > fMinChannel) {
        myss << "cr=" << fMinChannel << "-" << fMaxChannel << "&";
      }

      if (fValiditySQL != "") {
        myss << "where=" << fValiditySQL << "&";
      }

      if (fTag != "") myss << "tag=" << fTag << "&";

      //      char ts[256];
      
      if (fMinTSVld == fMaxTSVld) {
        //      sprintf(ts,"t=%" PRIu64,fMinTSVld);
        //        myss << ts; //"t=" << fMinTSVld;
        myss << "t=" << std::setprecision(12) << fMinTSVld;
      }
      else {
        //      sprintf(ts,"t0=%" PRIu64 "&t1=" PRIu64,fMinTSVld,fMaxTSVld);
        //        myss << ts; //"t0=" << fMinTSVld << "&t1=" << fMaxTSVld;
        myss << "t0=" << std::setprecision(12) << fMinTSVld << "&t1=" << std::setprecision(12) << fMaxTSVld;
      }

      if (fHasRecordTime) myss << "&rtime=" << fRecordTime;

      if (fFlushCache) myss << "&cache=flush";
      if (fDisableCache) myss << "&cache=no";

      myss << "&columns=";
      bool firstCol = true;
      for (int i=0; i<ncol; ++i) {
        std::string cName = this->GetCol(i)->Name();
        bool skipCol = false;
        for (size_t j=0; j<fExcludeCol.size(); ++j) 
          if (fExcludeCol[j] == cName) {
            skipCol = true;
            break;
          }
        if (skipCol) continue;
        if(!firstCol) myss << ",";
        myss << this->GetCol(i)->Name();
        firstCol = false;
      }

      //      std::cout << myss.str() << std::endl;
      Dataset ds;
      
      return GetDataFromWebService(ds,myss.str());

    }

bool nutools::dbi::Table::LoadFromCSV

(

std::string

fname

)

Definition at line 1298 of file Table.cpp.

References AddEmptyRows(), fCol, fin, fRow, fTableType, nutools::dbi::kConditionsTable, Name(), NewRow(), r, and value.

Referenced by GetCol(), LoadFromCSV(), and main().

    {
      std::cout << "Reading " << fname << std::endl;

      std::ifstream fin;
      fin.open(fname.c_str());
      if (!fin.is_open()) {
        std::cerr << "Could not open " << fname << std::endl;
        return false;
      }
      if (!fin.good()) {
        std::cerr << "Stream not good " << fname << std::endl;
        return false;
      }
      
      std::string s;
      
      char buff[256];
      std::string value;

      std::vector<int> colMap(fCol.size());
      for (unsigned int i=0; i<fCol.size(); ++i) {
        colMap[i] = int(i);
      }
      
      bool hasColNames = true;
      bool hasTols = true;

      int chanIdx=-1;
      int tvIdx=-1;
      int tvEndIdx=-1;

      // check first line to see if it is column names.  Should begin with a '#'
      std::getline(fin,s);
      if (s[0] == '#' || fTableType == kConditionsTable) {
        unsigned int ic=1;
        if (fTableType == kConditionsTable && s[0] != '#') ic=0;
        int k;

        int joff=0;
        for (int j=0; ic<s.length(); ++j) {
          k=0;

          while (s[ic++] != ',' && ic<s.length())
            buff[k++] = s[ic-1];

          if (ic==s.length()) buff[k++] = s[s.length()-1];
          buff[k] = '\0';
          value = buff;

          boost::algorithm::trim(value);
          if (value == "channel") { chanIdx=j; ++joff;}
          else if (value == "tv") { tvIdx=j; ++joff;}
          else if (value == "tvend") { tvEndIdx=j; ++joff;}
          else {
            for (unsigned int jc=0; jc<fCol.size(); ++jc)
              if (fCol[jc].Name() == value) {
                colMap[j-joff] = jc;
                break;
              }
          }
        }

      }
      else {
        hasColNames = false;
        fin.clear();
        fin.seekg(0);
      }

      // now check for tolerances
      std::getline(fin,s);
      if (fTableType == kConditionsTable && s.substr(0,10) == "tolerance,") {
        unsigned int ic=11;
        int k;

        int joff=0;
        for (int j=0; ic<s.length(); ++j) {
          k=0;
          while (s[ic] != ',' && ic<s.length())
            buff[k++] = s[ic++];
          //          if (ic==s.length()) buff[k++] = s[s.length()-1];
          ++ic;
          if (ic < s.length())
            buff[k] = '\0';
          else {
            buff[k] = '\0';
              }
          value = buff;
          if (value.length() > 0) {
            if (j==chanIdx || j==tvIdx || j==tvEndIdx) 
              ++joff;
            else 
              fCol[colMap[j-joff]].SetTolerance(atof(buff));
          }
        }       
      }
      else {
        hasTols = false;
        fin.clear();
        fin.seekg(0);
      }

      Row* r = NewRow();

      int nRow=0;
      unsigned int ioff=fRow.size();
      unsigned int irow=0;
      fin.clear();
      fin.seekg(0);
      while (std::getline(fin,s))
        ++nRow;
      fin.clear();
      fin.seekg(0);
      if (hasColNames) {
        --nRow;
        std::getline(fin,s);
      }
      if (hasTols) {
        --nRow;
        std::getline(fin,s);
      }

      if (nRow<=0) {
        std::cout << "Table::LoadFromCSV() found no rows in "
                  << fname << std::endl;
        return false;
      }

      AddEmptyRows(nRow);
      std::cout << "Added " << nRow << " empty rows" << std::endl;

      for (int jrow=0; jrow<nRow; ++jrow) {
        std::getline(fin,s);
        
        unsigned int ic=0;
        int k;
        bool hasX;
        int joff=0;
        for (int j=0; ic<s.length(); ++j) {
          k=0;
          hasX=false;
          while (s[ic++] != ',' && ic<s.length()) {
            buff[k++] = s[ic-1];
            if (buff[k-1] == 'x') hasX=true;
          }
          if (ic==s.length()) buff[k++] = s[s.length()-1];
          buff[k] = '\0';
          value = buff;

          if (j==chanIdx) {
            fRow[ioff+irow].SetChannel(strtoull(buff,NULL,10));
            ++joff;
          }
          else if (j==tvIdx) {
            fRow[ioff+irow].SetVldTime(strtoull(buff,NULL,10));
            ++joff;
          }
          else if (j==tvEndIdx) {
            fRow[ioff+irow].SetVldTimeEnd(strtoull(buff,NULL,10));
            ++joff;
          }
          else {
            if (hasX) {
              if (fCol[j-joff].Type() == "bigint" ||
                  fCol[j-joff].Type() == "long") {
                try {
                  std::istringstream iss(value);
                  uint64_t ulongValue;
                  iss >> std::hex >> ulongValue;
                  int64_t longValue = (int64_t) ulongValue;
                  value = boost::lexical_cast<std::string>(longValue);
                }
                catch (...) {
                  // simply let "value" remain unchanged
                }
              }
              else if (fCol[j-joff].Type() == "int") {
                try {
                  std::istringstream iss(value);
                  uint32_t uintValue;
                  iss >> std::hex >> uintValue;
                  int32_t intValue = (int32_t) uintValue;
                  value = boost::lexical_cast<std::string>(intValue);
                }
                catch (...) {
                  // simply let "value" remain unchanged
                }
              }
              else if (fCol[j-joff].Type() == "short") {
                try {
                  std::istringstream iss(value);
                  uint16_t ushortValue;
                  iss >> std::hex >> ushortValue;
                  int16_t shortValue = (int16_t) ushortValue;
                  value = boost::lexical_cast<std::string>(shortValue);
                }
                catch (...) {
                  // simply let "value" remain unchanged
                }
              }       
            } // if (hasX)
            if (fCol[j-joff].Type() == "text") {
                  boost::algorithm::trim(value);
                  if ((value[0] == '"' && value[value.length()-1] == '"') ||
                      (value[0] == '\'' && value[value.length()-1] == '\''))
                    value = value.substr(1,value.length()-2);
            }
            fRow[ioff+irow].Col(colMap[j-joff]).FastSet(value);
          } // else not a validity channel or time
        }

        fRow[ioff+irow].SetInDB();
        ++irow;
      }
      delete r;

      fin.close();

      return true;
    }

bool nutools::dbi::Table::LoadFromCSV ( const char *  fname )

inline

Definition at line 145 of file Table.h.

References LoadFromCSV(), LoadFromDB(), WriteToCSV(), and WriteToDB().

      { return LoadFromCSV(std::string(fname)); }

bool nutools::dbi::Table::LoadFromDB

(

)

Definition at line 1072 of file Table.cpp.

References AddEmptyRows(), CloseConnection(), ExistsInDB(), fCol, fConnection, fDescOrder, fDistinctCol, fHasConnection, fIgnoreDB, fOrderCol, fRow, fSchema, fSelectLimit, fSelectOffset, fTimeParsing, fTimeQueries, fValidityChanged, fValidityEnd, fValiditySQL, fValidityStart, fVerbosity, GetConnection(), Name(), and Schema().

Referenced by LoadFromCSV(), and LoadNonConditionsTable().

    {
      if (fIgnoreDB) return false;

      if (fSchema == "undef") {
        std::cerr << "Table::LoadFromDB: Detector not set!  Table::SetDetector()"
                  << " must be called first!" << std::endl;
        return false;
      }

      if (!fValidityChanged) return true;

      // make a connection to the dB if there isn't one already
      bool hasConn = fHasConnection;
      if (! fHasConnection) {
        GetConnection();
        hasConn = false;
      }

      if (!fConnection) {
        std::cerr << "Table::LoadFromDB: No connection to the database!" << std::endl;
        return false;
      }

      if (!ExistsInDB()) {
        std::cerr << "Table::LoadFromDB: Table \"" << Name()
                  << "\" not found in database!" << std::endl;
        CloseConnection();
        return false;
      }

      std::string cmd;
      cmd.clear();
      PGresult* res;

      std::ostringstream outs;
      outs << "BEGIN";
      res = PQexec(fConnection, outs.str().c_str());
      if (PQresultStatus(res) != PGRES_COMMAND_OK) {
        std::cerr << "BEGIN command failed: " << PQerrorMessage(fConnection) << std::endl;
        PQclear(res);
        CloseConnection();
        return false;
      }

      PQclear(res);

      outs.str("");
      outs << "DECLARE myportal CURSOR FOR SELECT ";
      if (!fDistinctCol.empty()) {
        outs << "DISTINCT ON (";
        if (! fDistinctCol.empty()) {
          for (unsigned int i=0; i<fDistinctCol.size(); ++i) {
            outs << fDistinctCol[i]->Name();
            if (i<(fDistinctCol.size()-1)) outs << ", ";
          }
        }
        outs << ") ";
      }

      outs << "* from ";
      outs << Schema() << "." << Name();

      if (! fValidityStart.empty() || fValiditySQL != "" ) {
        outs << " WHERE " << fValiditySQL;
        if (fValiditySQL != "" && !fValidityStart.empty()) outs << " and ";

        for (unsigned int i=0; i<fValidityStart.size(); ++i) {
          bool isEqualTo = (fValidityStart[i].Value() == fValidityEnd[i].Value());
          bool needsQuotes=false;
          if (fValidityStart[i].Type() == "string" ||
              fValidityStart[i].Type() == "text" ||
              fValidityStart[i].Type() == "timestamp" ||
              fValidityStart[i].Type() == "date") needsQuotes=true;

          outs << fValidityStart[i].Name();
          if (!isEqualTo)
            outs << ">=";
          else
            outs << "=";

          if (needsQuotes) outs << "'";
          outs << fValidityStart[i].Value();
          if (needsQuotes) outs << "'";
          
          if (!isEqualTo) {
            outs << " and ";
            outs << fValidityEnd[i].Name() + "<=";
            if (needsQuotes) outs << "'";
            outs << fValidityEnd[i].Value();
            if (needsQuotes) outs << "'";
          }

          if (i < (fValidityStart.size()-1)) outs << " and ";
        }
      }

      if (!fDistinctCol.empty() || !fOrderCol.empty()) {
        outs << " ORDER BY ";

        if (!fDistinctCol.empty()) {
          for (unsigned int i=0; i<fDistinctCol.size(); ++i) {
            outs << fDistinctCol[i]->Name();
            if (i<(fDistinctCol.size()-1)) outs << ", ";
          }
        }

        if (!fOrderCol.empty()) {
          for (unsigned int i=0; i<fOrderCol.size(); ++i) {
            outs << fOrderCol[i]->Name();
            if (i<(fOrderCol.size()-1)) outs << ", ";
          }
        }

        if (fDescOrder)
          outs << " DESC";
        else
          outs << " ASC";
      }

      if (fSelectLimit>0) {
        outs << " LIMIT " << boost::lexical_cast<std::string>(fSelectLimit);
      }

      if (fSelectOffset>0) {
        outs << " OFFSET " << boost::lexical_cast<std::string>(fSelectOffset);
      }

      if (fVerbosity > 0)
        std::cerr << "Table::LoadFromDB: Executing PGSQL command: \n\t" << outs.str() << std::endl;
      res = PQexec(fConnection,outs.str().c_str());

      if (PQresultStatus(res) != PGRES_COMMAND_OK) {
        std::cerr << "DECLARE CURSOR failed: " << PQerrorMessage(fConnection) << std::endl;
        PQclear(res);
        CloseConnection();
        return false;
      }
      PQclear(res);


      boost::posix_time::ptime ctt1;
      boost::posix_time::ptime ctt2;
    
      if (fTimeQueries) {
        ctt1 = boost::posix_time::microsec_clock::local_time();
      }

      res = PQexec(fConnection, "FETCH ALL in myportal");
      if (fTimeQueries) {
        ctt2 = boost::posix_time::microsec_clock::local_time();
        boost::posix_time::time_duration tdiff = ctt2 - ctt1;
        std::cerr << "Table::LoadFromDB(" << Name() << "): query took " 
                  << tdiff.total_milliseconds() << " ms" << std::endl;
      }

      if (PQresultStatus(res) != PGRES_TUPLES_OK) {
        std::cerr << "FETCH ALL failed: %" << PQerrorMessage(fConnection) << std::endl;
        PQclear(res);
        CloseConnection();
        return false;
      }

      // now cache rows
      int nRow = PQntuples(res);
      if (fVerbosity>0)
        std::cerr << "Table::LoadFromDB(" << Name() << "): got " << nRow 
                  << " rows of data." << std::endl;

      if (fTimeParsing)
        ctt1 = boost::posix_time::microsec_clock::local_time();

      if (nRow > 0) {
        std::vector<int> colMap(fCol.size());

        for (unsigned int i=0; i<fCol.size(); ++i) {
          colMap[i] = PQfnumber(res,fCol[i].Name().c_str());
        }

        int k;

        unsigned int ioff = fRow.size();
        AddEmptyRows(nRow);

        for (int i=0; i < nRow; i++) {
          for (unsigned int j=0; j < fCol.size(); j++) {
            k = colMap[j];
            if (k >= 0) {
              if (! PQgetisnull(res,i,k)) {
                std::string vstr = PQgetvalue(res,i,k);
                fRow[ioff+i].Col(j).FastSet(vstr);
              }
              //              else
              //                fRow[ioff+i].Col(j).FastSet("");
            }
          }
          fRow[ioff+i].SetInDB();
        }
      }

      if (fTimeParsing) {
        ctt2 = boost::posix_time::microsec_clock::local_time();
        boost::posix_time::time_duration tdiff = ctt2 - ctt1;
        std::cerr << "Table::LoadFromDB(" << Name() << "): parsing took " 
                  << tdiff.total_milliseconds() << " ms" << std::endl;
      }

      PQclear(res);

      /* close the portal ... we don't bother to check for errors ... */
      res = PQexec(fConnection, "CLOSE myportal");
      PQclear(res);

      /* end the transaction */
      res = PQexec(fConnection, "END");
      PQclear(res);

      // close connection to the dB if necessary
      if (! hasConn) CloseConnection();

      fValidityChanged = false;

      return true;
    }

bool nutools::dbi::Table::LoadNonConditionsTable ( )

private

Definition at line 1758 of file Table.cpp.

References fDescOrder, fDisableCache, fExcludeCol, fFlushCache, fOrderCol, fQEURL, fSelectLimit, fValidityEnd, fValiditySQL, fValidityStart, GetCol(), GetDataFromWebService(), LoadFromDB(), nutools::dbi::ColumnDef::Name(), Name(), NCol(), and Schema().

Referenced by Folder(), and Load().

    {
      if (fQEURL == "") {
        std::cerr << "Table::LoadNonConditionsTable: Query Engine URL is not set!  using Table::LoadFromDB() instead." << std::endl;
        return LoadFromDB();
      }

      if (fValiditySQL != "") {
        std::cerr << "Table::LoadNonConditionsTable: pure SQL statements are not supported, using Table::LoadFromDB() instead." << std::endl;
        return LoadFromDB();
      }

      std::stringstream myss;

      myss << fQEURL << "query?t=" << Schema() << "." << Name() << "&";

      int ncol = this->NCol();

      myss << "&c=";
      int nc=0;
      for (int i=0; i<ncol; ++i) {
        std::string cname = this->GetCol(i)->Name();
        bool skipCol = false;
        for (size_t j=0; j<fExcludeCol.size(); ++j) {
          if (fExcludeCol[j] == cname) {
            skipCol = true;
            break;
          }
        }
        if (skipCol) continue;

        if (nc>0)
          myss << ",";
        myss << cname;
        ++nc;
      }
      
      if (! fValidityStart.empty()) {
        for (unsigned int i=0; i<fValidityStart.size(); ++i) {
          if (fValidityStart[i].Type() == "string" ||
              fValidityStart[i].Type() == "text" ||
              fValidityStart[i].Type() == "timestamp" ||
              fValidityStart[i].Type() == "date") {
            std::cerr << "Table::LoadNonConditionsTable: validity strings are not supported, using Table::LoadFromDB() instead." << std::endl;
            return LoadFromDB();            
          }
          
          myss << "&w=";          
          bool isEqualTo = (fValidityStart[i].Value() == fValidityEnd[i].Value());
          if (isEqualTo) {
            myss << fValidityStart[i].Name() << ":"
                 << fValidityStart[i].Value();
          }
          else {
            myss << fValidityStart[i].Name() << ":ge:" 
                 << fValidityStart[i].Value() << "&w="
                 << fValidityEnd[i].Name() << ":le:"
                 << fValidityEnd[i].Value();
          }

        }
      }

      if (!fOrderCol.empty()) {
        myss << "&o="; 
        if (fDescOrder)
          myss << "-";
        for (unsigned int i=0; i<fOrderCol.size(); ++i) {
          myss << fOrderCol[i]->Name();
          if (i<(fOrderCol.size()-1)) myss << ", ";
        }
        
      }
      
      if (fSelectLimit>0)
        myss << "&l=" << fSelectLimit;

      if (fDisableCache) {
        if (fFlushCache)
          myss << "&x=clear";
        else
          myss << "&x=no";
      }

      Dataset ds;

      return GetDataFromWebService(ds,myss.str());

    }

bool nutools::dbi::Table::LoadUnstructuredConditionsTable ( )

private

Definition at line 1850 of file Table.cpp.

References fMaxTSVld, fMinTSVld, Folder(), fUConDBURL, Name(), and nutools::dbi::Util::RunningOnGrid().

Referenced by Folder(), and Load().

    {
      if (fMinTSVld == 0 || fMaxTSVld == 0) {
        std::cerr << "Table::LoadUnstructuredConditionsTable: No validity time is set!" << std::endl;
        return false;
      }

      if (fUConDBURL == "") {
        std::cerr << "Table::LoadConditionsTable: Web Service URL is not set!" << std::endl;
        return false;
      }

      if (!Util::RunningOnGrid()) {
        std::string interactiveURL = getenv("DBIUCONDBURLINT");
        if (!interactiveURL.empty())
          fUConDBURL = interactiveURL;
      }

      //      int ncol = this->NCol();

      std::stringstream myss;

      myss << fUConDBURL << "get?folder=" << Folder() << "." << Name() << "&";

      
      return false;
    }

bool nutools::dbi::Table::MakeConditionsCSVString ( std::stringstream &  ss )

private

Definition at line 2305 of file Table.cpp.

References nutools::dbi::Row::Channel(), nutools::dbi::Row::Col(), GetCol(), GetRow(), nutools::dbi::ColumnDef::Name(), NCol(), NRow(), Tolerance(), nutools::dbi::ColumnDef::Type(), nutools::dbi::Row::VldTime(), and nutools::dbi::Row::VldTimeEnd().

Referenced by Folder(), Write(), and WriteToCSV().

    {
      int ncol = this->NCol();
      int nrow = this->NRow();

      ss << "channel,tv,";
      bool first = true;
      for (int i=0; i<ncol; ++i) {
        std::string cname = this->GetCol(i)->Name();
        if(!first) ss << ",";
        first = false;
        ss << cname;
      }
      ss << std::endl;
      
      ss << "tolerance,,";
      first = true;
      for (int j=0; j<ncol; ++j) {
        std::string cname = this->GetCol(j)->Name();
        std::string ctype = this->GetCol(j)->Type();
        if(!first) ss << ",";
        first = false;
        float tol = this->Tolerance(cname);
        if (tol == 0.) {
          if (ctype == "double")
            ss << "1.e-10";
          else if (ctype == "float")
            ss << "1.e-5";
        }
        else
          ss << this->Tolerance(cname);
      }
      ss << std::endl;
      for (int i=0; i<nrow; ++i) {
        ss << GetRow(i)->Channel() << ","
           << GetRow(i)->VldTime() << ",";
        if (GetRow(i)->VldTimeEnd() > GetRow(i)->VldTime())
          ss << GetRow(i)->VldTimeEnd() << ",";
        first = true;
        for (int j=0; j<ncol; ++j) {
          if(!first) ss << ",";
          first = false;
          ss << GetRow(i)->Col(j);
        }
        ss << std::endl;
      }

      return true;
    }

std::string nutools::dbi::Table::Name ( )

inline

Definition at line 59 of file Table.h.

References fTableName.

Referenced by AddCol(), AddRow(), ExistsInDB(), GetCol(), GetColIndex(), GetCurrSeqVal(), GetDataFromWebService(), LoadConditionsTable(), LoadFromCSV(), LoadFromDB(), LoadNonConditionsTable(), LoadUnstructuredConditionsTable(), PrintPMUsed(), PrintVMUsed(), RemoveValidityRange(), SetTolerance(), SetValidityRange(), Table(), Tag(), Tolerance(), Write(), and WriteToDB().

{ return fTableName; }

int nutools::dbi::Table::NCol ( )

inline

Definition at line 102 of file Table.h.

References fCol.

Referenced by LoadConditionsTable(), LoadNonConditionsTable(), MakeConditionsCSVString(), and PrintColumns().

{return fCol.size();}

nutools::dbi::Row* const nutools::dbi::Table::NewRow ( )

inline

Definition at line 126 of file Table.h.

References fCol, GetColNames(), GetColNameToIndexMap(), and r.

Referenced by AddEmptyRows(), and LoadFromCSV().

{ Row* r = new Row(fCol); return r;}

int nutools::dbi::Table::NRow ( )

inline

Definition at line 103 of file Table.h.

References fRow.

Referenced by FillChanRowMap(), and MakeConditionsCSVString().

{return fRow.size();}

int nutools::dbi::Table::NVldChannels ( )

inline

Definition at line 287 of file Table.h.

References fChanRowMap.

{ return fChanRowMap.size(); }

int nutools::dbi::Table::NVldRows ( uint64_t  channel )

inline

Definition at line 286 of file Table.h.

References fChanRowMap.

{ return fChanRowMap[channel].size(); }

int nutools::dbi::Table::ParseSelfStatusLine ( char *  line )

private

Definition at line 1522 of file Table.cpp.

Referenced by Folder(), PrintPMUsed(), and PrintVMUsed().

    {
      int i = strlen(line);
      while (*line < '0' || *line > '9') line++;
      line[i-3] = '\0';
      i = atoi(line);
      return i;
    }

void nutools::dbi::Table::PrintColumns

(

)

Definition at line 645 of file Table.cpp.

References GetCol(), art::left(), nutools::dbi::ColumnDef::Name(), NCol(), and nutools::dbi::ColumnDef::Type().

Referenced by RemoveValidityRange().

    {
      std::cout << std::endl;
      int i = 0;
      std::vector<int> len(0);
      int tlen;
      //int sumlen = 0; // unused

      for ( ; i<this->NCol(); ++i) {
        tlen = this->GetCol(i)->Name().length();
        if ((int)this->GetCol(i)->Type().length() > tlen)
          tlen = this->GetCol(i)->Type().length();
        len.push_back(tlen);
        //sumlen += tlen; // unused
      }

      int nsp = 0;
      i = 0;
      int j = 0;
      while (i < this->NCol()) {
        for ( ; i<this->NCol() && nsp<78; ++i)
          nsp += len[i] + 1;

        for (int k=0; k<nsp; ++k) {
          std::cout << "_" ;
        }
        std::cout << std::endl;

        int j_save = j;
        for (; j<i; ++j)
          std::cout << "|" << std::setw(len[j]) << std::left << this->GetCol(j)->Name();
        std::cout << "|" << std::endl;

        for (int k=0; k<nsp; ++k) {
          std::cout << "-" ;
        }
        std::cout << std::endl;

        j = j_save;
        for ( ; j<i; ++j)
          std::cout << "|" << std::setw(len[j]) << std::left << this->GetCol(j)->Type();
        std::cout << "|" << std::endl;

        for (int k=0; k<nsp; ++k) {
          std::cout << "-" ;
        }
        std::cout << std::endl;

        nsp = 0;
      }

    }

void nutools::dbi::Table::PrintPMUsed

(

)

Definition at line 1553 of file Table.cpp.

References fclose(), file, Name(), ParseSelfStatusLine(), and Schema().

Referenced by SetChannelRange().

                           { //Note: this value is in MB!
      FILE* file = fopen("/proc/self/status", "r");
      int result = -1;
      char line[128];
    

      while (fgets(line, 128, file) != NULL){
        if (strncmp(line, "VmRSS:", 6) == 0){
          result = this->ParseSelfStatusLine(line);
          break;
        }
      }
      fclose(file);
      std::cerr << Schema() << "." << Name() << ": this process using " 
                << result/1024 << " MB of PhysicalMemory" << std::endl;
    }

void nutools::dbi::Table::PrintPQErrorMsg

(

)

const

Definition at line 493 of file Table.cpp.

References fConnection.

Referenced by GetPKeyCol().

    {
      if (fConnection)
        std::cerr << PQerrorMessage(fConnection) << std::endl;
    }

void nutools::dbi::Table::PrintVMUsed

(

)

Definition at line 1534 of file Table.cpp.

References fclose(), file, Name(), ParseSelfStatusLine(), and Schema().

Referenced by SetChannelRange().

                           { //Note: this value is in MB!
      FILE* file = fopen("/proc/self/status", "r");
      int result = -1;
      char line[128];
    

      while (fgets(line, 128, file) != NULL){
        if (strncmp(line, "VmSize:", 7) == 0){
          result = this->ParseSelfStatusLine(line);
          break;
        }
      }
      fclose(file);
      std::cerr << Schema() << "." << Name() << ": this process using " 
                << result/1024 << " MB of VirtualMemory" << std::endl;
    }

bool nutools::dbi::Table::RemoveDistinctColumn

(

unsigned int

i

)

Definition at line 2482 of file Table.cpp.

References fCol, and fDistinctCol.

Referenced by AddDistinctColumn(), and RemoveDistinctColumn().

    {
      if (i >= fCol.size()) return false;

      const ColumnDef* c = &fCol[i];
      for (unsigned int j=0; j<fDistinctCol.size(); ++j)
        if (fDistinctCol[j] == c) {
          fDistinctCol.erase(fDistinctCol.begin() + j);
          return true;
        }

      return false;
    }

bool nutools::dbi::Table::RemoveDistinctColumn

(

std::string

col

)

Definition at line 2518 of file Table.cpp.

References fDistinctCol, and GetCol().

    {
      const ColumnDef* c = GetCol(cname);

      if (!c) return false;

      for (unsigned int j=0; j<fDistinctCol.size(); ++j)
        if (fDistinctCol[j] == c) {
          fDistinctCol.erase(fDistinctCol.begin() + j);
          return true;
        }

      return false;
    }

bool nutools::dbi::Table::RemoveDistinctColumn ( const char *  col )

inline

Definition at line 162 of file Table.h.

References AddOrderColumn(), and RemoveDistinctColumn().

      { return RemoveDistinctColumn(std::string(col)); }

bool nutools::dbi::Table::RemoveOrderColumn

(

unsigned int

i

)

Definition at line 2554 of file Table.cpp.

References fCol, and fOrderCol.

Referenced by AddOrderColumn(), and RemoveOrderColumn().

    {
      if (i >= fCol.size()) return false;

      const ColumnDef* c = &fCol[i];
      for (unsigned int j=0; j<fOrderCol.size(); ++j)
        if (fOrderCol[j] == c) {
          fOrderCol.erase(fOrderCol.begin() + j);
          return true;
        }

      return false;
    }

bool nutools::dbi::Table::RemoveOrderColumn

(

std::string

col

)

Definition at line 2590 of file Table.cpp.

References fOrderCol, and GetCol().

    {
      const ColumnDef* c = GetCol(cname);

      if (!c) return false;

      for (unsigned int j=0; j<fOrderCol.size(); ++j)
        if (fOrderCol[j] == c) {
          fOrderCol.erase(fOrderCol.begin() + j);
          return true;
        }

      return false;
    }

bool nutools::dbi::Table::RemoveOrderColumn ( const char *  col )

inline

Definition at line 171 of file Table.h.

References RemoveOrderColumn().

      { return RemoveOrderColumn(std::string(col)); }

bool nutools::dbi::Table::RemoveRow

(

int

i

)

note, this will only delete a row from memory, it will not delete an existing row in a dB!

Definition at line 392 of file Table.cpp.

References fNullList, and fRow.

Referenced by ClearRows().

    {
      if (i < 0) return false;

      unsigned int j = i;

      if (j >= fRow.size()) return false;

      unsigned int kEnd = fNullList.size();
      for (unsigned int k=0; k<kEnd; ++k)
        if (fNullList[k].first == i) {
          fNullList.erase(fNullList.begin()+k);
          kEnd = fNullList.size();
        }

      fRow.erase(fRow.begin()+j);

      return true;
    }

void nutools::dbi::Table::RemoveValidityRange

(

std::string &

cname

)

Definition at line 2451 of file Table.cpp.

References fValidityEnd, fValidityStart, and Name().

Referenced by RemoveValidityRange(), and SetValidityRange().

    {
      unsigned int i=0;
      for (; i<fValidityStart.size(); ++i)
        if (fValidityStart[i].Name() == cname) {
          fValidityStart.erase(fValidityStart.begin()+i);
          fValidityEnd.erase(fValidityEnd.begin()+i);
        }
    }

void nutools::dbi::Table::RemoveValidityRange ( const char *  cname )

inline

Definition at line 256 of file Table.h.

References CloseConnection(), fValidityChanged, GetConnection(), PrintColumns(), and RemoveValidityRange().

      { std::string cstr(cname); return RemoveValidityRange(cstr); fValidityChanged=true;}

void nutools::dbi::Table::Reset ( )

private

Definition at line 467 of file Table.cpp.

References ClearValidity(), fConnection, fDescOrder, fDistinctCol, fExcludeCol, fHasConnection, fMaxChannel, fMinChannel, fPKeyList, fSelectLimit, fSelectOffset, and fVerbosity.

Referenced by Folder(), and Table().

    {
      fConnection = 0;
      fHasConnection = 0;
      fPKeyList.clear();
      fDistinctCol.clear();
      fVerbosity = 0;
      fDescOrder = true;
      fSelectLimit = 0;
      fSelectOffset = 0;
      ClearValidity();
      fMinChannel = 0;
      fMaxChannel = 0;
      fExcludeCol.clear();
    }

bool nutools::dbi::Table::ResetConnectionInfo

(

)

Referenced by GetConnectionTimeout().

void nutools::dbi::Table::ResetRole ( )

inline

Definition at line 98 of file Table.h.

References fRole, and fUser.

{ fRole = fUser; }

std::string nutools::dbi::Table::Role ( )

inline

Definition at line 63 of file Table.h.

References fRole.

{ return fRole; }

std::string nutools::dbi::Table::Schema ( )

inline

Definition at line 215 of file Table.h.

References fSchema.

Referenced by GetCurrSeqVal(), LoadConditionsTable(), LoadFromDB(), LoadNonConditionsTable(), PrintPMUsed(), PrintVMUsed(), Tag(), Write(), and WriteToDB().

{ return fSchema; }

void nutools::dbi::Table::SetChannelRange ( uint64_t  chan1, uint64_t  chan2  )

inline

Definition at line 312 of file Table.h.

References fMaxChannel, fMinChannel, GetColsFromDB(), PrintPMUsed(), and PrintVMUsed().

      { fMinChannel=chan1; fMaxChannel=chan2;}

void nutools::dbi::Table::SetConnectionTimeout ( int  n )

inline

Definition at line 263 of file Table.h.

References fConnectionTimeout, and n.

{ fConnectionTimeout=n;} // units in sec

void nutools::dbi::Table::SetDataSource

(

std::string

ds

)

Definition at line 537 of file Table.cpp.

References nutools::dbi::kDAQ, nutools::dbi::kDCS, nutools::dbi::kOffline, and nutools::dbi::kUnknownSource.

Referenced by nutools::dbi::DBIService::CreateTable(), and DataTypeMask().

                                          {
      if (ds == std::string("DAQ"))
        this->SetDataSource(nutools::dbi::kDAQ);
      else if (ds == std::string("DCS"))
        this->SetDataSource(nutools::dbi::kDCS);
      else if (ds == std::string("Offline"))
        this->SetDataSource(nutools::dbi::kOffline);
      else
        this->SetDataSource(nutools::dbi::kUnknownSource);
    }

void nutools::dbi::Table::SetDataSource

(

int

ids

)

Definition at line 549 of file Table.cpp.

References fDataSource, nutools::dbi::kNDataSources, and nutools::dbi::kUnknownSource.

                                     {
      if (ids >= 0 && ids < nutools::dbi::kNDataSources)
        fDataSource = ids;
      else
        fDataSource = nutools::dbi::kUnknownSource;
    }

void nutools::dbi::Table::SetDataTypeMask ( int  mask )

inline

Definition at line 76 of file Table.h.

References fDataTypeMask.

Referenced by main().

{ fDataTypeMask = mask;}

void nutools::dbi::Table::SetDBHost ( std::string  dbhost )

inline

Definition at line 85 of file Table.h.

References fDBHost.

Referenced by SetDBInfo(), and Table().

{ fDBHost = dbhost; }

void nutools::dbi::Table::SetDBHost ( const char *  dbhost )

inline

Definition at line 86 of file Table.h.

References fDBHost.

{ fDBHost = dbhost; }

void nutools::dbi::Table::SetDBInfo	(	std::string	name,
		std::string	host,
		std::string	port,
		std::string	user
	)

Definition at line 557 of file Table.cpp.

References SetDBHost(), SetDBName(), SetDBPort(), and SetUser().

Referenced by SetDBPort().

    {
      SetDBName(name);
      SetDBHost(host);
      SetDBPort(port);
      SetUser(user);
    }

void nutools::dbi::Table::SetDBInfo	(	const char *	name,
		const char *	host,
		const char *	port,
		const char *	user
	)

Definition at line 567 of file Table.cpp.

References SetDBHost(), SetDBName(), SetDBPort(), and SetUser().

    {
      SetDBName(name);
      SetDBHost(host);
      SetDBPort(port);
      SetUser(user);
    }

void nutools::dbi::Table::SetDBName ( std::string  dbname )

inline

Definition at line 83 of file Table.h.

References fDBName.

Referenced by SetDBInfo(), and Table().

{ fDBName = dbname; }

void nutools::dbi::Table::SetDBName ( const char *  dbname )

inline

Definition at line 84 of file Table.h.

References fDBName.

{ fDBName = dbname; }

void nutools::dbi::Table::SetDBPort ( std::string  p )

inline

Definition at line 87 of file Table.h.

References fDBPort.

Referenced by SetDBInfo(), and Table().

{ fDBPort = p; }

void nutools::dbi::Table::SetDBPort ( const char *  p )

inline

Definition at line 88 of file Table.h.

References fDBPort, SetDBInfo(), and SetPasswordFile().

{ fDBPort = p; }

bool nutools::dbi::Table::SetDetector

(

std::string

det

)

Definition at line 500 of file Table.cpp.

References fDetector, fSchema, fTableType, and nutools::dbi::kHardwareTable.

Referenced by nutools::dbi::DBIService::CreateTable(), main(), and SetValiditySQL().

    {
      fDetector = det;

      if (fTableType != kHardwareTable)
        fSchema = det;
      else
        fSchema = "public";

      boost::to_lower(fSchema);

      return true;
    }

void nutools::dbi::Table::SetFolder ( std::string  f )

inline

Definition at line 320 of file Table.h.

References f, and fFolder.

{ fFolder = f; }

void nutools::dbi::Table::SetIgnoreEnvVar ( bool  f )

inline

Definition at line 78 of file Table.h.

References f, and fIgnoreEnvVar.

{ fIgnoreEnvVar = f;}

void nutools::dbi::Table::SetMaxChannel ( uint64_t  chan )

inline

Definition at line 311 of file Table.h.

References fMaxChannel.

{fMaxChannel = chan;}

void nutools::dbi::Table::SetMaxTSVld ( double  t )

inline

Definition at line 272 of file Table.h.

References fMaxTSVld.

Referenced by main().

{ fMaxTSVld = t;}

void nutools::dbi::Table::SetMinChannel ( uint64_t  chan )

inline

Definition at line 310 of file Table.h.

References fMinChannel.

{fMinChannel = chan;}

void nutools::dbi::Table::SetMinTSVld ( double  t )

inline

Definition at line 271 of file Table.h.

References fMinTSVld.

Referenced by main().

{ fMinTSVld = t;}

void nutools::dbi::Table::SetOrderAsc ( )

inline

Definition at line 178 of file Table.h.

References fDescOrder.

{ fDescOrder = false; }

void nutools::dbi::Table::SetOrderDesc ( )

inline

Definition at line 177 of file Table.h.

References fDescOrder.

{ fDescOrder = true; }

bool nutools::dbi::Table::SetPasswordFile

(

const char *

fname = 0

)

fname should be the name of the file

Definition at line 859 of file Table.cpp.

References fin, and fPassword.

Referenced by GetConnection(), and SetDBPort().

    {
      std::string fNameStr = "";

      if (fname == 0) {
        char* tmpStr = getenv("DBIPWDFILE");
        if (tmpStr)
          fNameStr = tmpStr;
        else {
          std::cerr << "DBIPWDFILE env. variable is not set, disabling "
                    << "password-access to the dB." << std::endl;
          fPassword = "";
          return false;
        }
      }
      else
        fNameStr = fname;

      std::ifstream fin;
      fin.open(fNameStr.c_str());
      if (!fin.is_open() || !fin.good()) {
        std::cerr << "Could not open password file " << fNameStr
                  << ".  Disabling password-access to the dB." << std::endl;
        return false;
      }
      else {
        fin >> fPassword;
        fin.close();
      }

      return true;
    }

void nutools::dbi::Table::SetQEURL ( std::string  url )

inline

Definition at line 303 of file Table.h.

References fQEURL.

Referenced by nutools::dbi::DBIService::CreateTable().

{ fQEURL = url;}

void nutools::dbi::Table::SetRecordTime

(

double

t

)

Definition at line 450 of file Table.cpp.

References fHasRecordTime, and fRecordTime.

Referenced by VldChannels().

    {
      fRecordTime = t;
      fHasRecordTime = true;
    }

bool nutools::dbi::Table::SetRole

(

std::string

role

)

Definition at line 852 of file Table.cpp.

References fRole.

Referenced by SetUser().

    {
      fRole = role;
      return true;
    }

bool nutools::dbi::Table::SetRole

(

const char *

role

)

void nutools::dbi::Table::SetSchema ( std::string  s )

inline

Definition at line 214 of file Table.h.

References fSchema.

{ fSchema = s; }

void nutools::dbi::Table::SetSelectLimit ( int  limit )

inline

Definition at line 174 of file Table.h.

References fSelectLimit.

{ fSelectLimit=limit; }

void nutools::dbi::Table::SetSelectOffset ( int  offset )

inline

Definition at line 175 of file Table.h.

References fSelectOffset.

{ fSelectOffset=offset; }

void nutools::dbi::Table::SetTableName

(

std::string

tname

)

Definition at line 524 of file Table.cpp.

References fTableName.

Referenced by nutools::dbi::DBIService::CreateTable(), DataTypeMask(), main(), and Table().

                                            {
      boost::to_lower(tname);
      fTableName = tname;
    }

void nutools::dbi::Table::SetTableName

(

const char *

tname

)

Definition at line 530 of file Table.cpp.

References fTableName.

                                              {
      std::string tnameStr = tname;
      boost::to_lower(tnameStr);
      fTableName = tnameStr;
    }

bool nutools::dbi::Table::SetTableType

(

int

t

)

Definition at line 458 of file Table.cpp.

References fTableType, and nutools::dbi::kNTableType.

Referenced by nutools::dbi::DBIService::CreateTable(), DataTypeMask(), and main().

    {
      if (t < 0 || t >= kNTableType) return false;
      fTableType = t;

      return true;
    }

void nutools::dbi::Table::SetTag ( std::string  s )

inline

Definition at line 277 of file Table.h.

References fTag.

{ fTag = s; }

void nutools::dbi::Table::SetTimeParsing ( bool  f )

inline

Definition at line 306 of file Table.h.

References f, and fTimeParsing.

Referenced by nutools::dbi::DBIService::CreateTable().

{fTimeParsing = f; }

void nutools::dbi::Table::SetTimeQueries ( bool  f )

inline

Definition at line 305 of file Table.h.

References f, and fTimeQueries.

Referenced by nutools::dbi::DBIService::CreateTable().

{fTimeQueries = f; }

void nutools::dbi::Table::SetTolerance	(	std::string &	cname,
		float	t
	)

Definition at line 619 of file Table.cpp.

References fCol, and Name().

Referenced by GetCol().

    {
      unsigned int i=0;
      for ( ; i < fCol.size(); ++i)
        if (fCol[i].Name() == cname) break;

      if (i >= fCol.size()) return;

      fCol[i].SetTolerance(t);

    }

void nutools::dbi::Table::SetUser ( std::string  uname )

inline

Definition at line 79 of file Table.h.

References fUser.

Referenced by nutools::dbi::DBIService::CreateTable(), SetDBInfo(), and Table().

{ fUser = uname; }

void nutools::dbi::Table::SetUser ( const char *  uname )

inline

Definition at line 80 of file Table.h.

References fUser, and SetRole().

{ fUser = uname; }

template<class T >

bool nutools::dbi::Table::SetValidityRange ( std::string  cname, T  start, T  end  )

inline

Definition at line 218 of file Table.h.

References util::end(), fValidityChanged, fValidityEnd, fValidityStart, GetCol(), nutools::dbi::ColumnDef::Name(), Name(), and nutools::dbi::ColumnDef::Type().

Referenced by SetValidityRange().

        {
          const ColumnDef* c = this->GetCol(cname);
          if (c) {
            // check to see if this makes sense for a boolean column.
            if (c->Type() == "bool")
              if (start != end) return false;

            // check to see that this column wasn't already added to valid.
            // list if it is, overwrite it

            unsigned int i=0;
            for (; i<fValidityStart.size(); ++i)
              if (fValidityStart[i].Name() == c->Name()) break;

            if (i == fValidityStart.size()) {
              fValidityStart.push_back(ColumnDef(*c));
              fValidityEnd.push_back(ColumnDef(*c));
            }
            std::stringstream startSS;
            startSS << start;
            std::stringstream endSS;
            endSS << end;
            fValidityStart[i].SetValue(startSS.str());
            fValidityEnd[i].SetValue(endSS.str());
            fValidityChanged=true;
            return true;
          }

          return false;
        }

template<class T >

bool nutools::dbi::Table::SetValidityRange ( std::string  cname, T  start  )

inline

Definition at line 251 of file Table.h.

References RemoveValidityRange(), and SetValidityRange().

                                                        {
        return (this->SetValidityRange(cname,start,start));
      }

void nutools::dbi::Table::SetValiditySQL ( std::string  cmd )

inline

Definition at line 209 of file Table.h.

References fValidityChanged, fValiditySQL, GetDetector(), and SetDetector().

{ fValiditySQL = cmd; fValidityChanged=true;}

void nutools::dbi::Table::SetVerbosity ( int  i )

inline

Definition at line 100 of file Table.h.

References fVerbosity.

Referenced by nutools::dbi::DBIService::CreateTable(), and main().

{ fVerbosity = i;}

void nutools::dbi::Table::SetWSURL ( std::string  url )

inline

Definition at line 302 of file Table.h.

References fWSURL.

Referenced by nutools::dbi::DBIService::CreateTable().

{ fWSURL = url;}

int nutools::dbi::Table::TableType ( )

inline

Definition at line 65 of file Table.h.

References fTableType.

{ return fTableType; }

bool nutools::dbi::Table::Tag	(	std::string	tn = "",
		bool	override = false
	)

Definition at line 2053 of file Table.cpp.

References fTag, fWSURL, GetPassword(), Name(), and Schema().

Referenced by GetTag(), and main().

    {
      if (tn != "") fTag = tn;

      if (fTag == "") return false;

      std::stringstream myss;

      myss << fWSURL << "tag?table=" << Schema() << "." << Name() << "&";
      myss << "tag=" << fTag;
      if (override)
        myss << "&override=yes";

      int status;
      std::string pwd = GetPassword();

      postHTTPsigned(myss.str().c_str(), pwd.c_str(), NULL, 0, NULL, 0, &status);

      return (status==0);
    }

bool nutools::dbi::Table::TimeParsing ( )

inline

Definition at line 308 of file Table.h.

References fTimeParsing.

{return fTimeParsing; }

bool nutools::dbi::Table::TimeQueries ( )

inline

Definition at line 307 of file Table.h.

References fTimeQueries.

{return fTimeQueries; }

float nutools::dbi::Table::Tolerance

(

std::string &

cname

)

Definition at line 632 of file Table.cpp.

References fCol, and Name().

Referenced by GetCol(), and MakeConditionsCSVString().

    {
      unsigned int i=0;
      for ( ; i < fCol.size(); ++i)
        if (fCol[i].Name() == cname) break;

      if (i >= fCol.size()) return 0.;

      return fCol[i].Tolerance();

    }

std::string nutools::dbi::Table::User ( )

inline

Definition at line 62 of file Table.h.

References fUser.

{ return fUser; }

std::vector<uint64_t> nutools::dbi::Table::VldChannels ( )

inline

Definition at line 288 of file Table.h.

References fChannelVec, GetVldRow(), GetVldRows(), and SetRecordTime().

{ return fChannelVec; }

bool nutools::dbi::Table::Write

(

bool

commit = true

)

Definition at line 2356 of file Table.cpp.

References fDataTypeMask, fTimeQueries, fVerbosity, fWSURL, GetPassword(), nutools::dbi::kDataOnly, nutools::dbi::kMCOnly, MakeConditionsCSVString(), Name(), nutools::dbi::Util::RunningOnGrid(), and Schema().

Referenced by GetTag(), and main().

    {
      if (fDataTypeMask == 0){
        std::cerr << "Table::Write: Data type mask is not set!" << std::endl;
        return false;
      }

      if (fWSURL == "") {
        std::cerr << "Table::Write: Web Service URL is not set!" << std::endl;
        return false;
      }

      if (!Util::RunningOnGrid()) {
        std::string putURL = getenv("DBIWSURLPUT");
        if (!putURL.empty())
          fWSURL = putURL;
      }
      
      std::stringstream ss;

      MakeConditionsCSVString(ss);

      int status;
      std::string url = fWSURL + "put?table=" + Schema() + "." + Name();

      std::stringstream typeStr;
      typeStr << "&type=";
      if ((fDataTypeMask & kMCOnly)) typeStr << "mc";
      if ((fDataTypeMask & kDataOnly)) typeStr << "data";
      
      url += typeStr.str();

      // get web service password
      std::string pwd = GetPassword();

      boost::posix_time::ptime ctt1;
      boost::posix_time::ptime ctt2;
      
      if (fTimeQueries) 
        ctt1 = boost::posix_time::microsec_clock::local_time();
              
      if (fVerbosity>0)
        std::cout << "Posting data to: " << url << std::endl;

      postHTTPsigned(url.c_str(), pwd.c_str(), NULL, 0,
                     ss.str().c_str(), ss.str().length(), &status);
      if (fTimeQueries) {
        ctt2 = boost::posix_time::microsec_clock::local_time();
        boost::posix_time::time_duration tdiff = ctt2 - ctt1;
        std::cerr << "Table::Write(" << Name() << "): query took " 
                  << tdiff.total_milliseconds() << " ms" << std::endl;
      }
      return (status == 0);
    }

bool nutools::dbi::Table::WriteToCSV	(	std::string	fname,
		bool	appendToFile = false,
		bool	writeColNames = false
	)

Definition at line 2412 of file Table.cpp.

References CheckForNulls(), fCol, fRow, fTableType, nutools::dbi::kConditionsTable, and MakeConditionsCSVString().

Referenced by LoadFromCSV(), main(), and WriteToCSV().

    {
      if (! CheckForNulls()) return false;
      
      std::ofstream fout;
      if (!appendToFile)
        fout.open(fname.c_str());
      else
        fout.open(fname.c_str(),std::ios_base::app);

      if (fTableType==kConditionsTable) {       
        std::stringstream ss;
        MakeConditionsCSVString(ss);
        fout << ss.str();
      }
      else {
        if (writeColNames) {
          for (unsigned int j=0; j<fCol.size(); ++j) {
            fout << fCol[j].Name();
            if (j<fCol.size()-1) fout << ",";     
          }
        }
        
        for (unsigned int i=0; i<fRow.size(); ++i) {
          for (unsigned int j=0; j<fCol.size(); ++j) {
            fout << fRow[i].Col(j);
            if (j<fCol.size()-1) fout << ",";
          }
          fout << std::endl;
        }
      }

      fout.close();

      return true;
    }

bool nutools::dbi::Table::WriteToCSV ( const char *  fname, bool  appendToFile = false, bool  writeColNames = false  )

inline

Definition at line 151 of file Table.h.

References AddDistinctColumn(), ClearValidity(), col, and WriteToCSV().

      { return WriteToCSV(std::string(fname),appendToFile,writeColNames); }

bool nutools::dbi::Table::WriteToDB

(

bool

commit = true

)

use commit=false if just testing

Definition at line 2075 of file Table.cpp.

References addInsertTime, addInsertUser, addUpdateTime, addUpdateUser, CacheDBCommand(), CheckForNulls(), CloseConnection(), nutools::dbi::Row::Col(), e, ExistsInDB(), fCol, fConnection, fHasConnection, fIgnoreDB, fPKeyList, fRow, fSchema, fTimeQueries, fUser, fVerbosity, GetColNameToIndexMap(), GetConnection(), GetConnectionInfo(), nutools::dbi::Util::GetCurrentTimeAsString(), GetCurrSeqVal(), nutools::dbi::Column::Modified(), Name(), nutools::dbi::Row::NModified(), r, Schema(), nutools::dbi::Row::Set(), and nutools::dbi::Row::Update().

Referenced by LoadFromCSV().

    {
      if (! CheckForNulls()) return false;

      bool doWrite = ! fIgnoreDB;
      bool hasConn = fHasConnection;

      try {
        GetConnectionInfo();
      }
      catch (std::runtime_error& e) {
        std::cerr << e.what() << std::endl;
        return false;
      }

      // make a connection to the dB if one doesn't already exist
      if (doWrite) {
        if (! fHasConnection) {
          GetConnection();
          hasConn = false;
        }

        if (!fConnection) {
          std::cerr << "Table::WriteToDB: No connection to the database!" << std::endl;
          doWrite = false;
        }
        else {
          // now check that the table actually exists...
          if (!ExistsInDB()) {
            std::cerr << "Table::WriteToDB: Table does not exist in database!"
                      << std::endl;
            doWrite = false;
          }
        }
      }

      bool retVal = true;

      // get current timestamp:
      std::string ts = Util::GetCurrentTimeAsString();

      PGresult* res = PQexec(fConnection, "BEGIN");
      if (PQresultStatus(res) != PGRES_COMMAND_OK) {
        std::cerr << "BEGIN command failed: " << PQerrorMessage(fConnection) << std::endl;
        PQclear(res);
        CloseConnection();
        return false;
      }

      PQclear(res);

      std::string cmd = "SET search_path TO " + fSchema;
      res = PQexec(fConnection, cmd.c_str());
      if (PQresultStatus(res) != PGRES_COMMAND_OK) {
        std::cerr << "\'" << cmd << "\' command failed" << std::endl;
        PQclear(res);
        CloseConnection();
        return false;
      }
      PQclear(res);
      cmd.clear();

      std::map<std::string,int> colMap = GetColNameToIndexMap();
      int insertTimeIdx = colMap["inserttime"];
      int insertUserIdx = colMap["insertuser"];
      int updateTimeIdx = colMap["updatetime"];
      int updateUserIdx = colMap["updateuser"];
      // now create the INSERT command
      for (unsigned int i=0; i<fRow.size(); ++i) {
        // do an INSERT only if this entry does not already exists in the dB
        if (! fRow[i].InDB()) {
          Row r(fRow[i]);
          if (addInsertTime) r.Set(insertTimeIdx,ts);
          if (addInsertUser) r.Set(insertUserIdx,fUser);

          int nrowInsert = fCol.size();
          for (unsigned int j=0; j<fCol.size(); ++j) {
            if (fCol[j].Name() == "updatetime")
              nrowInsert--;
            else if (fCol[j].Name() == "updateuser")
              nrowInsert--;
            else if (fCol[j].Type() == "autoincr")
              nrowInsert--;
          }

          std::ostringstream outs;

          int ic=0;
          outs << "INSERT INTO " << Schema() << "." << Name() << " (";
          for (unsigned int j=0; j<fCol.size(); ++j) {
            if (fCol[j].Name() == "updatetime") continue;
            if (fCol[j].Name() == "updateuser") continue;
            if (fCol[j].Type() == "autoincr") continue;

            outs << fCol[j].Name();
            if (ic < nrowInsert-1) outs << ",";
            ++ic;
          }
          outs << ") VALUES (";

          ic = 0;
          for (unsigned int j=0; j<fCol.size(); ++j) {
            if (fCol[j].Name() == "updatetime") continue;
            if (fCol[j].Name() == "updateuser") continue;
            if (fCol[j].Type() == "autoincr") continue;

            outs << r.Col(j);

            if (ic < nrowInsert-1)  outs << ",";
            ++ic;
          }

          outs << ")";

          if (fVerbosity > 0)
            std::cerr << "Table::WriteToDB: Executing PGSQL command: \n\t"
                      << outs.str() << std::endl;

          if (!commit)
            std::cout << outs.str() << std::endl;
          else {
            if (doWrite) {
              boost::posix_time::ptime ctt1;
              boost::posix_time::ptime ctt2;
              
              if (fTimeQueries) 
                ctt1 = boost::posix_time::microsec_clock::local_time();
              
              res = PQexec(fConnection, outs.str().c_str());
              
              if (fTimeQueries) {
                ctt2 = boost::posix_time::microsec_clock::local_time();
                boost::posix_time::time_duration tdiff = ctt2 - ctt1;
                std::cerr << "Table::WriteToDB(" << Name() << "): query took " 
                          << tdiff.total_milliseconds() << " ms" << std::endl;
              }
              
              if (PQresultStatus(res) != PGRES_COMMAND_OK) {
                CacheDBCommand(outs.str());
                std::cerr << "INSERT failed: " << PQerrorMessage(fConnection)
                          << std::endl;
                retVal = false;
              }
              else {
                fRow[i].SetInDB();
                // set insert columns
                if (addInsertTime) fRow[i].Col(insertTimeIdx).Set(ts);
                if (addInsertUser) fRow[i].Col(insertUserIdx).Set(fUser);
                // set autoincr columns
                long iseq;
                std::string seqstr;
                for (unsigned int j=0; j<fCol.size(); ++j) {
                  if (fCol[j].Type() == "autoincr") {
                    if (this->GetCurrSeqVal(fCol[j].Name(),iseq)) {
                      seqstr = boost::lexical_cast<std::string>(iseq);
                      fRow[i].Col(j).Set(seqstr,true);
                    }
                  }
                }
              }
              PQclear(res);
            }
            else
              CacheDBCommand(outs.str());
          }
        }
        else {
          if ( fRow[i].NModified() > 0 ) {
            Row r(fRow[i]);
            if (addUpdateTime) r.Update(updateTimeIdx,ts);
            if (addUpdateUser) r.Update(updateUserIdx,fUser);
            std::ostringstream outs;
            outs << "UPDATE " << Schema() << "." << Name() << " SET ";
            int im = 0;
            for (unsigned int j=0; j<fCol.size() && im < r.NModified(); ++j) {
              if (r.Col(j).Modified()) {
                outs << fCol[j].Name() + "=";
                outs << r.Col(j);
                ++im;
                if (im < r.NModified()) outs << ",";
              }
            }
            outs << " WHERE ";
            // now print out all pkey values
            int nkey = fPKeyList.size();
            for (int j=0; j<nkey; ++j) {
              std::string pkey = fPKeyList[j]->Name();
              int pkeyIdx = colMap[pkey];
              outs << pkey << "=" << r.Col(pkeyIdx);
              if (j < (nkey-1)) outs << " and ";
            }

            if (fVerbosity > 0)
              std::cerr << "Table::WriteToDB: Executing PGSQL command: \n\t"
                        << outs.str() << std::endl;

            if (!commit)
              std::cout << outs.str() << std::endl;
            else {
              if (doWrite) {
                res = PQexec(fConnection, outs.str().c_str());
                if (PQresultStatus(res) != PGRES_COMMAND_OK) {
                  CacheDBCommand(outs.str());
                  std::cerr << "UPDATE failed: " << PQerrorMessage(fConnection) << std::endl;
                  retVal = false;
                }
                else {
                  // set update columns
                  if (addUpdateTime) fRow[i].Col(updateTimeIdx).Set(ts);
                  if (addUpdateUser) fRow[i].Col(updateUserIdx).Set(fUser);
                }
                PQclear(res);
              }
              else
                CacheDBCommand(outs.str());
            }
          }
        }
      }

      res = PQexec(fConnection, "END");
      PQclear(res);

      // close connection to the dB if necessary
      if (! hasConn) CloseConnection();

      return retVal;
    }

Friends And Related Function Documentation

std::ostream& operator<< ( std::ostream &  stream, const Table &  t  )

friend

Definition at line 414 of file Table.h.

Referenced by GetConnectionTimeout().

                                                                       {
      for (unsigned int j=0; j<t.fRow.size(); ++j) {
        stream << t.fRow[j] << std::endl;
      }
      return stream;
    }

Member Data Documentation

bool nutools::dbi::Table::addInsertTime

private

Definition at line 341 of file Table.h.

Referenced by AddCol(), GetColsFromDB(), Table(), and WriteToDB().

bool nutools::dbi::Table::addInsertUser

private

Definition at line 342 of file Table.h.

Referenced by AddCol(), GetColsFromDB(), Table(), and WriteToDB().

bool nutools::dbi::Table::addUpdateTime

private

Definition at line 343 of file Table.h.

Referenced by AddCol(), GetColsFromDB(), Table(), and WriteToDB().

bool nutools::dbi::Table::addUpdateUser

private

Definition at line 344 of file Table.h.

Referenced by AddCol(), GetColsFromDB(), Table(), and WriteToDB().

std::vector<uint64_t> nutools::dbi::Table::fChannelVec

private

Definition at line 398 of file Table.h.

Referenced by FillChanRowMap(), and VldChannels().

std::unordered_map<uint64_t,std::vector<nutools::dbi::Row*> > nutools::dbi::Table::fChanRowMap

private

Definition at line 399 of file Table.h.

Referenced by ClearChanRowMap(), FillChanRowMap(), GetVldRow(), GetVldRows(), NVldChannels(), and NVldRows().

std::vector<nutools::dbi::ColumnDef> nutools::dbi::Table::fCol

private

Definition at line 387 of file Table.h.

Referenced by AddCol(), AddDistinctColumn(), AddOrderColumn(), AddRow(), CheckForNulls(), GetCol(), GetColIndex(), GetColName(), GetColNames(), GetColNameToIndexMap(), GetColsFromDB(), GetDataFromWebService(), LoadFromCSV(), LoadFromDB(), NCol(), NewRow(), RemoveDistinctColumn(), RemoveOrderColumn(), SetTolerance(), Table(), Tolerance(), WriteToCSV(), and WriteToDB().

PGconn* nutools::dbi::Table::fConnection

private

Definition at line 401 of file Table.h.

Referenced by CloseConnection(), ExecuteSQL(), ExistsInDB(), GetColsFromDB(), GetConnection(), GetCurrSeqVal(), LoadFromDB(), PrintPQErrorMsg(), Reset(), Table(), and WriteToDB().

int nutools::dbi::Table::fConnectionTimeout

private

Definition at line 361 of file Table.h.

Referenced by GetConnection(), GetConnectionTimeout(), GetDataFromWebService(), Load(), SetConnectionTimeout(), and Table().

int nutools::dbi::Table::fDataSource

private

Definition at line 364 of file Table.h.

Referenced by DataSource(), SetDataSource(), and Table().

int nutools::dbi::Table::fDataTypeMask

private

Definition at line 363 of file Table.h.

Referenced by DataTypeMask(), LoadConditionsTable(), SetDataTypeMask(), Table(), and Write().

std::string nutools::dbi::Table::fDBCacheFile

private

Definition at line 376 of file Table.h.

Referenced by CacheDBCommand(), and Table().

std::string nutools::dbi::Table::fDBHost

private

Definition at line 372 of file Table.h.

Referenced by DBHost(), GetConnection(), GetConnectionInfo(), SetDBHost(), and Table().

std::string nutools::dbi::Table::fDBName

private

Definition at line 373 of file Table.h.

Referenced by DBName(), GetConnection(), GetConnectionInfo(), SetDBName(), and Table().

std::string nutools::dbi::Table::fDBPort

private

Definition at line 371 of file Table.h.

Referenced by DBPort(), GetConnection(), GetConnectionInfo(), SetDBPort(), and Table().

bool nutools::dbi::Table::fDescOrder

private

Definition at line 347 of file Table.h.

Referenced by LoadFromDB(), LoadNonConditionsTable(), Reset(), SetOrderAsc(), and SetOrderDesc().

std::string nutools::dbi::Table::fDetector

private

Definition at line 379 of file Table.h.

Referenced by GetDetector(), SetDetector(), and Table().

bool nutools::dbi::Table::fDisableCache

private

Definition at line 354 of file Table.h.

Referenced by DisableCache(), EnableCache(), LoadConditionsTable(), and LoadNonConditionsTable().

std::vector<const nutools::dbi::ColumnDef*> nutools::dbi::Table::fDistinctCol

private

Definition at line 393 of file Table.h.

Referenced by AddDistinctColumn(), Clear(), LoadFromDB(), RemoveDistinctColumn(), and Reset().

std::vector<std::string> nutools::dbi::Table::fExcludeCol

private

Definition at line 396 of file Table.h.

Referenced by AddExcludeCol(), ClearExcludedCols(), LoadConditionsTable(), LoadNonConditionsTable(), and Reset().

bool nutools::dbi::Table::fExistsInDB

private

Definition at line 350 of file Table.h.

Referenced by ExistsInDB(), GetColsFromDB(), and Table().

bool nutools::dbi::Table::fFlushCache

private

Definition at line 353 of file Table.h.

Referenced by DisableFlushCache(), EnableFlushCache(), LoadConditionsTable(), and LoadNonConditionsTable().

std::string nutools::dbi::Table::fFolder

private

Definition at line 380 of file Table.h.

Referenced by Folder(), SetFolder(), and Table().

bool nutools::dbi::Table::fHasConnection

private

Definition at line 351 of file Table.h.

Referenced by CloseConnection(), ExecuteSQL(), ExistsInDB(), GetColsFromDB(), GetConnection(), GetCurrSeqVal(), LoadFromDB(), Reset(), Table(), WriteToDB(), and ~Table().

bool nutools::dbi::Table::fHasRecordTime

private

Definition at line 352 of file Table.h.

Referenced by ClearRecordTime(), LoadConditionsTable(), and SetRecordTime().

bool nutools::dbi::Table::fIgnoreDB

private

Definition at line 348 of file Table.h.

Referenced by ExecuteSQL(), ExistsInDB(), GetConnection(), GetCurrSeqVal(), LoadFromDB(), Table(), and WriteToDB().

bool nutools::dbi::Table::fIgnoreEnvVar

private

Definition at line 345 of file Table.h.

Referenced by GetConnectionInfo(), SetIgnoreEnvVar(), and Table().

uint64_t nutools::dbi::Table::fMaxChannel

private

Definition at line 366 of file Table.h.

Referenced by LoadConditionsTable(), Reset(), SetChannelRange(), SetMaxChannel(), and Table().

double nutools::dbi::Table::fMaxTSVld

private

Definition at line 405 of file Table.h.

Referenced by GetMaxTSVld(), LoadConditionsTable(), LoadUnstructuredConditionsTable(), and SetMaxTSVld().

uint64_t nutools::dbi::Table::fMinChannel

private

Definition at line 365 of file Table.h.

Referenced by LoadConditionsTable(), Reset(), SetChannelRange(), SetMinChannel(), and Table().

double nutools::dbi::Table::fMinTSVld

private

Definition at line 406 of file Table.h.

Referenced by GetMinTSVld(), LoadConditionsTable(), LoadUnstructuredConditionsTable(), and SetMinTSVld().

std::vector<std::pair<int,int> > nutools::dbi::Table::fNullList

private

Definition at line 395 of file Table.h.

Referenced by AddRow(), CheckForNulls(), Clear(), ClearRows(), and RemoveRow().

std::vector<const nutools::dbi::ColumnDef*> nutools::dbi::Table::fOrderCol

private

Definition at line 394 of file Table.h.

Referenced by AddOrderColumn(), Clear(), LoadFromDB(), LoadNonConditionsTable(), and RemoveOrderColumn().

std::string nutools::dbi::Table::fPassword

private

Definition at line 377 of file Table.h.

Referenced by ClearPassword(), DisablePasswordAccess(), GetConnection(), and SetPasswordFile().

std::vector<const nutools::dbi::ColumnDef*> nutools::dbi::Table::fPKeyList

private

Definition at line 392 of file Table.h.

Referenced by GetNPKeyCol(), GetPKeyCol(), Reset(), and WriteToDB().

std::string nutools::dbi::Table::fQEURL

private

Definition at line 385 of file Table.h.

Referenced by LoadNonConditionsTable(), SetQEURL(), and Table().

double nutools::dbi::Table::fRecordTime

private

Definition at line 407 of file Table.h.

Referenced by LoadConditionsTable(), and SetRecordTime().

std::string nutools::dbi::Table::fRole

private

Definition at line 370 of file Table.h.

Referenced by ResetRole(), Role(), and SetRole().

std::vector<nutools::dbi::Row> nutools::dbi::Table::fRow

private

Definition at line 388 of file Table.h.

Referenced by AddEmptyRows(), AddRow(), Clear(), ClearRows(), GetDataFromWebService(), GetRow(), LoadFromCSV(), LoadFromDB(), NRow(), nutools::dbi::operator<<(), RemoveRow(), WriteToCSV(), and WriteToDB().

std::string nutools::dbi::Table::fSchema

private

Definition at line 374 of file Table.h.

Referenced by ExistsInDB(), GetColsFromDB(), LoadFromDB(), Schema(), SetDetector(), SetSchema(), Table(), and WriteToDB().

int nutools::dbi::Table::fSelectLimit

private

Definition at line 359 of file Table.h.

Referenced by LoadFromDB(), LoadNonConditionsTable(), Reset(), and SetSelectLimit().

int nutools::dbi::Table::fSelectOffset

private

Definition at line 360 of file Table.h.

Referenced by LoadFromDB(), Reset(), and SetSelectOffset().

std::string nutools::dbi::Table::fTableName

private

Definition at line 368 of file Table.h.

Referenced by GetColsFromDB(), Name(), SetTableName(), and Table().

int nutools::dbi::Table::fTableType

private

Definition at line 362 of file Table.h.

Referenced by ExistsInDB(), GetColsFromDB(), Load(), LoadFromCSV(), SetDetector(), SetTableType(), Table(), TableType(), and WriteToCSV().

std::string nutools::dbi::Table::fTag

private

Definition at line 382 of file Table.h.

Referenced by GetTag(), LoadConditionsTable(), SetTag(), Table(), and Tag().

bool nutools::dbi::Table::fTestedExists

private

Definition at line 349 of file Table.h.

Referenced by ExistsInDB(), and Table().

bool nutools::dbi::Table::fTimeParsing

private

Definition at line 356 of file Table.h.

Referenced by GetDataFromWebService(), LoadFromDB(), SetTimeParsing(), Table(), and TimeParsing().

bool nutools::dbi::Table::fTimeQueries

private

Definition at line 355 of file Table.h.

Referenced by ExecuteSQL(), GetDataFromWebService(), LoadFromDB(), SetTimeQueries(), Table(), TimeQueries(), Write(), and WriteToDB().

std::string nutools::dbi::Table::fUConDBURL

private

Definition at line 384 of file Table.h.

Referenced by LoadUnstructuredConditionsTable(), and Table().

std::string nutools::dbi::Table::fUser

private

Definition at line 369 of file Table.h.

Referenced by GetConnection(), GetConnectionInfo(), ResetRole(), SetUser(), Table(), User(), and WriteToDB().

bool nutools::dbi::Table::fValidityChanged

private

Definition at line 346 of file Table.h.

Referenced by Clear(), ClearRows(), ClearValidity(), LoadFromDB(), RemoveValidityRange(), SetValidityRange(), and SetValiditySQL().

std::vector<nutools::dbi::ColumnDef> nutools::dbi::Table::fValidityEnd

private

Definition at line 391 of file Table.h.

Referenced by Clear(), ClearValidity(), LoadFromDB(), LoadNonConditionsTable(), RemoveValidityRange(), and SetValidityRange().

std::string nutools::dbi::Table::fValiditySQL

private

Definition at line 378 of file Table.h.

Referenced by Clear(), ClearValidity(), GetValiditySQL(), LoadConditionsTable(), LoadFromDB(), LoadNonConditionsTable(), and SetValiditySQL().

std::vector<nutools::dbi::ColumnDef> nutools::dbi::Table::fValidityStart

private

Definition at line 390 of file Table.h.

Referenced by Clear(), ClearValidity(), LoadFromDB(), LoadNonConditionsTable(), RemoveValidityRange(), and SetValidityRange().

short nutools::dbi::Table::fVerbosity

private

Definition at line 357 of file Table.h.

Referenced by CheckForNulls(), CloseConnection(), ExecuteSQL(), ExistsInDB(), GetColsFromDB(), GetConnection(), GetCurrSeqVal(), GetDataFromWebService(), LoadFromDB(), Reset(), SetVerbosity(), Table(), Write(), and WriteToDB().

std::string nutools::dbi::Table::fWSURL

private

Definition at line 383 of file Table.h.

Referenced by LoadConditionsTable(), SetWSURL(), Table(), Tag(), and Write().

---

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

• nuevdb/v1_09_08/source/nuevdb/IFDatabase/Table.h
• nuevdb/v1_09_08/source/nuevdb/IFDatabase/Table.cpp