ATLAS Offline Software
Loading...
Searching...
No Matches
Classes | Public Types | Public Member Functions | Private Member Functions | Private Attributes | List of all members
GenericDbTable Class Reference

#include <GenericDbTable.h>

Inheritance diagram for GenericDbTable:
Collaboration diagram for GenericDbTable:

Classes

struct  CondDBColumn
 Definition of the columns. More...
struct  CondDBColumnArrayBool
struct  CondDBColumnArrayDouble
struct  CondDBColumnArrayFloat
struct  CondDBColumnArrayInt
struct  CondDBColumnArrayLong
struct  CondDBColumnArrayString
struct  CondDBColumnBool
struct  CondDBColumnDouble
struct  CondDBColumnFloat
struct  CondDBColumnInt
struct  CondDBColumnLong
struct  CondDBColumnString

Public Types

enum  dataTypes {
  kNull =0 , kBool , kInt , kFloat ,
  kString , kDouble , kLongLong , kArrayBool ,
  kArrayFloat , kArrayInt , kArrayString , kArrayDouble ,
  kArrayLongLong
}
enum  CondDBErrorCode {
  CDB_NOT_INITIALIZED = -1 , CDB_RANGE_ERROR = -2 , CDB_TYPE_ERROR = -3 , CDB_SUCCESS = -4 ,
  CDB_ALLOC_ERROR = -5 , CDB_STRTOARRAY_ERROR = -6
}

Public Member Functions

 GenericDbTable ()
 Default constructor.
 GenericDbTable (unsigned n_columns, int n_rows=0)
 Default constructor.
 ~GenericDbTable ()
 Object destructor.
int getNames (std::vector< std::string > &names) const
 This method gets a vector containing the names of all columns in the table.
int getTypes (std::vector< dataTypes > &types) const
 This method gets a vector containing the data types of all columns in the table.
int getNull (unsigned n_column, float &null) const
 Get Null value for column.
int getNull (unsigned n_column, long int &null) const
int getNull (unsigned n_column, int64 &null) const
int getNull (unsigned n_column, double &null) const
int getNull (unsigned n_column, std::string &null) const
int setName (unsigned n_column, const std::string &name)
 This method defines the name for a specified column.
int setType (unsigned n_column, dataTypes type)
 This method defines the data type for a specified column.
int setNull (unsigned n_column, const float &null)
 Set Null value for column.
int setNull (unsigned n_column, const long int &null)
int setNull (unsigned n_column, const int64 &null)
int setNull (unsigned n_column, const double &null)
int setNull (unsigned n_column, const std::string &null)
void Initialize (unsigned n_columns, int n_rows=0)
 This method initializes a table created by the default constructor If the table had the number of columns already defined this does nothing.
int getRow (unsigned rowNumber, std::vector< std::string > &values) const
 This method returns a vector of strings with allelements in a row In case the cell has an array the first string has the number of elements (following strings) belonging to the array.
int getRowID (std::string &pID) const
 This method returns, for a given ID, the row number.
int getCell (unsigned n_column, unsigned n_row, short int &ndata) const
 This method gets a value from a cell in a column of long ints (int in MySQL)
int getCell (unsigned n_column, unsigned n_row, long int &ndata) const
 This method gets a value from a cell in a column of long ints (int in MySQL)
int getCell (unsigned n_column, unsigned n_row, int64 &ndata) const
 This method gets a value from a cell in a column of long long ints (bigint in MySQL)
int getCell (unsigned n_column, unsigned n_row, float &ndata) const
 This method gets a value from a cell in a column of floats.
int getCell (unsigned n_column, unsigned n_row, std::string &ndata) const
 This method gets a value from a cell in a column of strings.
int getCell (unsigned n_column, unsigned n_row, double &ndata) const
 This method gets a value from a cell in a column of doubles.
int getCell (unsigned n_column, unsigned n_row, std::vector< short int > &ndata) const
 This method gets a value from a cell in a column of vectors of bools.
int getCell (unsigned n_column, unsigned n_row, std::vector< long int > &ndata) const
 This method gets a value from a cell in a column of vectors of long ints (int in MySQL - 4bytes)
int getCell (unsigned n_column, unsigned n_row, std::vector< int64 > &ndata) const
 This method gets a value from a cell in a column of vectors of long long ints (bigint in MySQL - 8bytes)
int getCell (unsigned n_column, unsigned n_row, std::vector< float > &ndata) const
 This method gets a value from a cell in a column of vectors of floats.
int getCell (unsigned n_column, unsigned n_row, std::vector< std::string > &ndata) const
 This method gets a value from a cell in a column of vector of strings.
int getCell (unsigned n_column, unsigned n_row, std::vector< double > &ndata) const
 This method gets a value from a cell in a column of vector of doubles.
int getCell (const std::string &colName, unsigned int n_row, short int &data) const
 This method get's a value from a column of floats by its name instead the column number (.
int getCell (const std::string &colName, unsigned int n_row, long int &data) const
int getCell (const std::string &colName, unsigned int n_row, int64 &data) const
int getCell (const std::string &colName, unsigned int n_row, float &data) const
int getCell (const std::string &colName, unsigned int n_row, double &data) const
int getCell (const std::string &colName, unsigned int n_row, std::string &data) const
int getCell (const std::string &colName, unsigned int n_row, std::vector< short int > &data) const
int getCell (const std::string &colName, unsigned int n_row, std::vector< long int > &data) const
int getCell (const std::string &colName, unsigned int n_row, std::vector< int64 > &data) const
int getCell (const std::string &colName, unsigned int n_row, std::vector< float > &data) const
int getCell (const std::string &colName, unsigned int n_row, std::vector< double > &data) const
int getCell (const std::string &colName, unsigned int n_row, std::vector< std::string > &data) const
int setCell (unsigned n_column, unsigned n_row, const short int ndata)
 set data methods
int setCell (unsigned n_column, unsigned n_row, const long int ndata)
 This method changes a value from a cell in a column of long ints.
int setCell (unsigned n_column, unsigned n_row, const int64 ndata)
 This method changes a value from a cell in a column of long long ints.
int setCell (unsigned n_column, unsigned n_row, const float ndata)
 This method changes a value from a cell in a column of floats.
int setCell (unsigned n_column, unsigned n_row, const std::string &ndata)
 This method changes a value from a cell in a column of strings.
int setCell (unsigned n_column, unsigned n_row, const double ndata)
 This method changes a value from a cell in a column of doubles.
int setCell (unsigned n_column, unsigned n_row, const std::vector< short int > &ndata)
 This method changes a value from a cell in a column of vectors of bools.
int setCell (unsigned n_column, unsigned n_row, const std::vector< long int > &ndata)
 This method changes a value from a cell in a column of vectors of long ints.
int setCell (unsigned n_column, unsigned n_row, const std::vector< int64 > &ndata)
 This method changes a value from a cell in a column of vectors of long long ints.
int setCell (unsigned n_column, unsigned n_row, const std::vector< float > &ndata)
 This method changes a value from a cell in a column of vectors of floats.
int setCell (unsigned n_column, unsigned n_row, const std::vector< std::string > &ndata)
 This method changes a value from a cell in a column of vectors of strings.
int setCell (unsigned n_column, unsigned n_row, const std::vector< double > &ndata)
 This method changes a value from a cell in a column of vectors of doubles.
int setColumndata (unsigned n_column, const std::vector< short int > &data)
 The following methods allow to insert in the columns a group of values.
int setColumndata (unsigned n_column, const std::vector< long int > &data)
 Insert a subset in a column of long ints.
int setColumndata (unsigned n_column, const std::vector< int64 > &data)
 Insert a subset in a column of long long ints.
int setColumndata (unsigned n_column, const std::vector< float > &data)
 Insert a subset in a column of floats.
int setColumndata (unsigned n_column, const std::vector< std::string > &data)
 Insert a subset in a column of strings.
int setColumndata (unsigned n_column, const std::vector< double > &data)
 Insert a subset in a column of doubles.
int setColumndata (unsigned n_column, const std::vector< std::vector< short int > > &data)
 Insert a subset in a column of vectors of bools.
int setColumndata (unsigned n_column, const std::vector< std::vector< long int > > &data)
 Insert a subset in a column of vectors of long ints.
int setColumndata (unsigned n_column, const std::vector< std::vector< int64 > > &data)
 Insert a subset in a column of vectors of long long ints.
int setColumndata (unsigned n_column, const std::vector< std::vector< float > > &data)
 Insert a subset in a column of vectors of floats.
int setColumndata (unsigned n_column, const std::vector< std::vector< std::string > > &data)
 Insert a subset in a column of vectors of strings.
int setColumndata (unsigned n_column, const std::vector< std::vector< double > > &data)
 Insert a subset in a column of vectors of doubles.
void resize (int num_rows)
 Reserves more rows on the table.
unsigned getNumRows () const
 Returns the number of rows RESERVED in the table.
unsigned getNumColumns () const
 Returns the number of columns in the table.

Private Member Functions

template<typename T, typename COLUMN>
int __getNull (T &data, COLUMN *tmpColumn) const
 Templated method for handling the null values.
template<typename T, typename COLUMN>
int __getCell (unsigned n_column, unsigned n_row, T &ndata, dataTypes type, COLUMN *tmpColumn) const
 Templated method that get's the data from a specified cell This is the method that does the real work.
template<typename T, typename COLUMN>
int __setCell (unsigned n_column, unsigned n_row, const T &ndata, dataTypes type, COLUMN *tmpColumn)
 Templated method that set's the data in a specified cell This is the method that does the real work.
template<typename T, typename COLUMN>
int __setColumnData (unsigned n_column, T &data, dataTypes type, COLUMN *tmpColumn)
 Templated method that set's portions of data in a specified column This method is deprecated and hence should not be used.
template<typename T>
int __getCellByName (const std::string &colName, unsigned int n_row, T &data) const
 Templated method that get's column data using the column name This method get's the desired column number and calls getCell(...)
void verifyInitialization ()
 Verifies if all columns are initialized.
template<class TYPE>
std::string ToString (const TYPE &t) const
 Auxiliary function to convert any value to string.

Private Attributes

bool m_isInitialized
std::vector< CondDBColumn * > m_conddbtable
unsigned m_numRows

Detailed Description

Definition at line 20 of file GenericDbTable.h.

Member Enumeration Documentation

◆ CondDBErrorCode

enum GenericDbTable::CondDBErrorCode
Enumerator
CDB_NOT_INITIALIZED 
CDB_RANGE_ERROR 
CDB_TYPE_ERROR 
CDB_SUCCESS 
CDB_ALLOC_ERROR 
CDB_STRTOARRAY_ERROR 

Definition at line 42 of file GenericDbTable.h.

42 {CDB_NOT_INITIALIZED = -1,
43 CDB_RANGE_ERROR = -2,
44 CDB_TYPE_ERROR = -3,
45 CDB_SUCCESS = -4,
46 CDB_ALLOC_ERROR = -5,
47 CDB_STRTOARRAY_ERROR = -6};

◆ dataTypes

enum GenericDbTable::dataTypes
Enumerator
kNull 
kBool 
kInt 
kFloat 
kString 
kDouble 
kLongLong 
kArrayBool 
kArrayFloat 
kArrayInt 
kArrayString 
kArrayDouble 
kArrayLongLong 

Definition at line 25 of file GenericDbTable.h.

25 {kNull=0,
26 kBool,
27 kInt,
28 kFloat,
29 kString,
30 kDouble,
31 kLongLong,
32 kArrayBool,
33 kArrayFloat,
34 kArrayInt,
35 kArrayString,
36 kArrayDouble,
37 kArrayLongLong
38 };

Constructor & Destructor Documentation

◆ GenericDbTable() [1/2]

GenericDbTable::GenericDbTable ( )
inline

Default constructor.

Parameters
n_columnsis the number of columns of the table
n_rowsis the number of rows that must be reserved (OPTIONAL)

Definition at line 55 of file GenericDbTable.h.

55{m_isInitialized = false; m_numRows=0;}

◆ GenericDbTable() [2/2]

GenericDbTable::GenericDbTable ( unsigned n_columns,
int n_rows = 0 )

Default constructor.

Parameters
n_columnsis the number of columns of the table
n_rowsis the number of rows that must be reserved (OPTIONAL)

Definition at line 28 of file GenericDbTable.cxx.

28 :m_numRows(n_rows)
29{
30
31 m_numRows=0;
32 m_isInitialized = false;
33 unsigned i;
34
35 for (i=0;i<n_columns; i++)
36 m_conddbtable.push_back(new CondDBColumn);
37
38 for (i = 0; i<m_conddbtable.size(); i++ )
39 {
40 m_conddbtable[i]->initialized = false;
41 m_conddbtable[i]->type = kNull;
42 }
43
44 if (n_rows)
45 {
46 resize(n_rows);
47 // status = vector<CondDBStatus>(n_rows,untouched);
48 }
49}
GenericDbTable::m_conddbtable
std::vector< CondDBColumn * > m_conddbtable
Definition GenericDbTable.h:734
GenericDbTable::resize
void resize(int num_rows)
Reserves more rows on the table.
Definition GenericDbTable.cxx:1587
GenericDbTable::CondDBColumn
Definition of the columns.
Definition GenericDbTable.h:663

◆ ~GenericDbTable()

GenericDbTable::~GenericDbTable ( )

Object destructor.

Definition at line 53 of file GenericDbTable.cxx.

54{
55 for (unsigned i=0; i< m_conddbtable.size(); i++)
56 {
57 delete m_conddbtable[i];
58 }
59}

Member Function Documentation

◆ __getCell()

template<typename T, typename COLUMN>
int GenericDbTable::__getCell ( unsigned n_column,
unsigned n_row,
T & ndata,
dataTypes type,
COLUMN * tmpColumn ) const
private

Templated method that get's the data from a specified cell This is the method that does the real work.

See also
getCell(...)

Definition at line 1762 of file GenericDbTable.cxx.

1763{
1764
1765 if (!m_isInitialized)
1766 return CDB_NOT_INITIALIZED;
1767
1768 if ((m_numRows > n_row) && (m_conddbtable.size() > n_column))
1769 {
1770 if (m_conddbtable[n_column]->type == type)
1771 {
1772 if (tmpColumn->column.size() <= n_row)
1773 ndata = tmpColumn->column.back();
1774 else
1775 ndata = tmpColumn->column[n_row+1];
1776 }
1777
1778 else
1779 return CDB_TYPE_ERROR;
1780 }
1781 else
1782 return CDB_RANGE_ERROR;
1783
1784 return CDB_SUCCESS;
1785}

◆ __getCellByName()

template<typename T>
int GenericDbTable::__getCellByName ( const std::string & colName,
unsigned int n_row,
T & data ) const
private

Templated method that get's column data using the column name This method get's the desired column number and calls getCell(...)

See also
getCell(...)

Definition at line 1851 of file GenericDbTable.cxx.

1852{
1853 for (unsigned int i=0; i< m_conddbtable.size(); i++) {
1854 if (m_conddbtable[i]->name == colName)
1855 {
1856 return getCell(i,n_row,data);
1857 }
1858 }
1859 //if there's no column with this name return error
1860 return CDB_RANGE_ERROR;
1861}
data
char data[hepevt_bytes_allocation_ATLAS]
Definition HepEvt.cxx:11
GenericDbTable::getCell
int getCell(unsigned n_column, unsigned n_row, short int &ndata) const
This method gets a value from a cell in a column of long ints (int in MySQL)
Definition GenericDbTable.cxx:687

◆ __getNull()

template<typename T, typename COLUMN>
int GenericDbTable::__getNull ( T & data,
COLUMN * tmpColumn ) const
inlineprivate

Templated method for handling the null values.

Parameters
datais the variable that will return the NULL value
tmpColumnis an auxiliary variable holding the pointer for the desired column
Returns
an error code

Definition at line 595 of file GenericDbTable.h.

596 {
597 data = tmpColumn->column[0];
598 return CDB_SUCCESS;
599 }

◆ __setCell()

template<typename T, typename COLUMN>
int GenericDbTable::__setCell ( unsigned n_column,
unsigned n_row,
const T & ndata,
dataTypes type,
COLUMN * tmpColumn )
private

Templated method that set's the data in a specified cell This is the method that does the real work.

See also
setCell(...)

Definition at line 1788 of file GenericDbTable.cxx.

1789 {
1790 if (!m_isInitialized)
1791 return CDB_NOT_INITIALIZED;
1792
1793 if ((m_numRows > n_row) && (m_conddbtable.size() > n_column))
1794 {
1795 if (m_conddbtable[n_column]->type == type)
1796 {
1797 // static_cast<COLUMN*>(m_conddbtable[n_column])->column[n_row+1] = ndata;
1798 if (tmpColumn->column.size() == (n_row+1))
1799 tmpColumn->column.push_back(ndata);
1800 else
1801 if (tmpColumn->column.size() < (n_row+1))
1802 {
1803 T tmp = tmpColumn->column.back();
1804
1805 while((n_row)-tmpColumn->column.size())
1806 {
1807 tmpColumn->column.push_back(tmp);
1808 }
1809 tmpColumn->column.push_back(ndata);
1810 }
1811 else
1812 // if the cell already has a value
1813 tmpColumn->column[n_row+1] = ndata;
1814
1815 return CDB_SUCCESS;
1816 }
1817 else
1818 return CDB_TYPE_ERROR;
1819 }
1820 else
1821 return CDB_RANGE_ERROR;
1822 }
TSU::T
unsigned long long T
Definition L1TopoDataTypes.h:35

◆ __setColumnData()

template<typename T, typename COLUMN>
int GenericDbTable::__setColumnData ( unsigned n_column,
T & data,
dataTypes type,
COLUMN * tmpColumn )
private

Templated method that set's portions of data in a specified column This method is deprecated and hence should not be used.

See also
setCell(...)

Definition at line 1825 of file GenericDbTable.cxx.

1826{
1827 if (!m_isInitialized)
1828 return CDB_NOT_INITIALIZED;
1829
1830 unsigned index = 0;
1831 if (n_column < m_conddbtable.size())
1832 {
1833 if (m_conddbtable[n_column]->type == type)
1834 {
1835 while((tmpColumn->column.size() < m_numRows+1) && (index < data.size()))
1836 {
1837 tmpColumn->column.push_back(data[index]);
1838 index++;
1839 }
1840 return index;
1841
1842 }
1843 else
1844 return CDB_TYPE_ERROR;
1845 }
1846 else
1847 return CDB_RANGE_ERROR;
1848}
DeMoScan.index
str index
Definition DeMoScan.py:362

◆ getCell() [1/24]

int GenericDbTable::getCell ( const std::string & colName,
unsigned int n_row,
double & data ) const

Definition at line 846 of file GenericDbTable.cxx.

847{
848 return __getCellByName<double>(colName, n_row, data);
849}
GenericDbTable::__getCellByName
int __getCellByName(const std::string &colName, unsigned int n_row, T &data) const
Templated method that get's column data using the column name This method get's the desired column nu...
Definition GenericDbTable.cxx:1851

◆ getCell() [2/24]

int GenericDbTable::getCell ( const std::string & colName,
unsigned int n_row,
float & data ) const

Definition at line 842 of file GenericDbTable.cxx.

843{
844 return __getCellByName<float>(colName,n_row,data);
845}

◆ getCell() [3/24]

int GenericDbTable::getCell ( const std::string & colName,
unsigned int n_row,
int64 & data ) const

Definition at line 838 of file GenericDbTable.cxx.

839{
840 return __getCellByName<int64>(colName, n_row, data);
841}

◆ getCell() [4/24]

int GenericDbTable::getCell ( const std::string & colName,
unsigned int n_row,
long int & data ) const

Definition at line 834 of file GenericDbTable.cxx.

835{
836return __getCellByName<long int>(colName, n_row, data);
837}

◆ getCell() [5/24]

int GenericDbTable::getCell ( const std::string & colName,
unsigned int n_row,
short int & data ) const

This method get's a value from a column of floats by its name instead the column number (.

See also
getCell(unsigned, unsigned,T&))
Parameters
colNameis the column name (
See also
getNames)
Parameters
n_rowis the row number
datais the reference for a variable that will return the value
Returns
an error code

Definition at line 829 of file GenericDbTable.cxx.

830{
831 return __getCellByName(colName,n_row,data);
832}

◆ getCell() [6/24]

int GenericDbTable::getCell ( const std::string & colName,
unsigned int n_row,
std::string & data ) const

Definition at line 850 of file GenericDbTable.cxx.

851{
852 return __getCellByName<std::string>(colName, n_row, data);
853}

◆ getCell() [7/24]

int GenericDbTable::getCell ( const std::string & colName,
unsigned int n_row,
std::vector< double > & data ) const

Definition at line 870 of file GenericDbTable.cxx.

871{
872 return __getCellByName<std::vector<double> >(colName, n_row, data);
873}

◆ getCell() [8/24]

int GenericDbTable::getCell ( const std::string & colName,
unsigned int n_row,
std::vector< float > & data ) const

Definition at line 866 of file GenericDbTable.cxx.

867{
868 return __getCellByName<std::vector<float> >(colName, n_row, data);
869}

◆ getCell() [9/24]

int GenericDbTable::getCell ( const std::string & colName,
unsigned int n_row,
std::vector< int64 > & data ) const

Definition at line 862 of file GenericDbTable.cxx.

863{
864 return __getCellByName<std::vector<int64> >(colName, n_row, data);
865}

◆ getCell() [10/24]

int GenericDbTable::getCell ( const std::string & colName,
unsigned int n_row,
std::vector< long int > & data ) const

Definition at line 858 of file GenericDbTable.cxx.

859{
860 return __getCellByName<std::vector<long int> >(colName, n_row, data);
861}

◆ getCell() [11/24]

int GenericDbTable::getCell ( const std::string & colName,
unsigned int n_row,
std::vector< short int > & data ) const

Definition at line 854 of file GenericDbTable.cxx.

855{
856 return __getCellByName< std::vector<short int> >(colName, n_row, data);
857}

◆ getCell() [12/24]

int GenericDbTable::getCell ( const std::string & colName,
unsigned int n_row,
std::vector< std::string > & data ) const

Definition at line 874 of file GenericDbTable.cxx.

875{
876 return __getCellByName<std::vector<string> >(colName, n_row, data);
877}

◆ getCell() [13/24]

int GenericDbTable::getCell ( unsigned n_column,
unsigned n_row,
double & ndata ) const

This method gets a value from a cell in a column of doubles.

Parameters
n_columnis the column number
n_rowis the row number
ndatais the reference to the valriable where the value will be returned
Returns
an error code

Definition at line 783 of file GenericDbTable.cxx.

784{
785 CondDBColumnDouble *tmpColumn = static_cast<CondDBColumnDouble*>(m_conddbtable[n_column]);
786 return __getCell(n_column, n_row, ndata, kDouble, tmpColumn);
787}
GenericDbTable::__getCell
int __getCell(unsigned n_column, unsigned n_row, T &ndata, dataTypes type, COLUMN *tmpColumn) const
Templated method that get's the data from a specified cell This is the method that does the real work...
Definition GenericDbTable.cxx:1762

◆ getCell() [14/24]

int GenericDbTable::getCell ( unsigned n_column,
unsigned n_row,
float & ndata ) const

This method gets a value from a cell in a column of floats.

Parameters
n_columnis the column number
n_rowis the row number
ndatais the reference to the valriable where the value will be returned
Returns
an error code

Definition at line 700 of file GenericDbTable.cxx.

701{
702 CondDBColumnFloat *tmpColumn = static_cast<CondDBColumnFloat*>(m_conddbtable[n_column]);
703 return __getCell(n_column, n_row, ndata, kFloat, tmpColumn);
704}

◆ getCell() [15/24]

int GenericDbTable::getCell ( unsigned n_column,
unsigned n_row,
int64 & ndata ) const

This method gets a value from a cell in a column of long long ints (bigint in MySQL)

Parameters
n_columnis the column number
n_rowis the row number
ndatais the reference to the valriable where the value will be returned
Returns
an error code

Definition at line 693 of file GenericDbTable.cxx.

694{
695 CondDBColumnLong *tmpColumn = static_cast<CondDBColumnLong*>(m_conddbtable[n_column]);
696 return __getCell(n_column, n_row, ndata, kLongLong, tmpColumn);
697}

◆ getCell() [16/24]

int GenericDbTable::getCell ( unsigned n_column,
unsigned n_row,
long int & ndata ) const

This method gets a value from a cell in a column of long ints (int in MySQL)

Parameters
n_columnis the column number
n_rowis the row number
ndatais the reference to the valriable where the value will be returned
Returns
an error code

Definition at line 681 of file GenericDbTable.cxx.

682{
683 CondDBColumnInt *tmpColumn = static_cast<CondDBColumnInt*>(m_conddbtable[n_column]);
684 return __getCell(n_column, n_row, ndata, kInt, tmpColumn);
685}

◆ getCell() [17/24]

int GenericDbTable::getCell ( unsigned n_column,
unsigned n_row,
short int & ndata ) const

This method gets a value from a cell in a column of long ints (int in MySQL)

Parameters
n_columnis the column number
n_rowis the row number
ndatais the reference to the valriable where the value will be returned
Returns
an error code

Definition at line 687 of file GenericDbTable.cxx.

688{
689 CondDBColumnBool *tmpColumn = static_cast<CondDBColumnBool*>(m_conddbtable[n_column]);
690 return __getCell(n_column, n_row, ndata, kBool, tmpColumn);
691}

◆ getCell() [18/24]

int GenericDbTable::getCell ( unsigned n_column,
unsigned n_row,
std::string & ndata ) const

This method gets a value from a cell in a column of strings.

Parameters
n_columnis the column number
n_rowis the row number
ndatais the reference to the valriable where the value will be returned
Returns
an error code

Definition at line 706 of file GenericDbTable.cxx.

707{
708
709 int status;
710
711 if (!m_isInitialized)
712 return CDB_NOT_INITIALIZED;
713
714 if ((m_numRows > n_row) && (m_conddbtable.size() > n_column))
715 {
716 if (m_conddbtable[n_column]->type == kString) {
717 CondDBColumnString *tmpColumn = static_cast<CondDBColumnString*>(m_conddbtable[n_column]);
718 return __getCell(n_column, n_row, ndata, kString, tmpColumn);
719 }
720 else {
721 switch(m_conddbtable[n_column]->type)
722 {
723 case kInt:
724 {
725 long int aux;
726 CondDBColumnInt *tmpColumn = static_cast<CondDBColumnInt*>(m_conddbtable[n_column]);
727 status = __getCell(n_column, n_row, aux , kInt, tmpColumn);
728 if (status == CDB_SUCCESS)
729 ndata = ToString(aux);
730 break;
731 }
732 case kBool:
733 {
734 short int aux;
735 CondDBColumnBool *tmpColumn = static_cast<CondDBColumnBool*>(m_conddbtable[n_column]);
736 status = __getCell(n_column, n_row, aux, kBool, tmpColumn);
737 if (status == CDB_SUCCESS)
738 ndata = ToString(aux);
739 break;
740 }
741
742 case kLongLong:
743 {
744 long long aux;
745 CondDBColumnLong *tmpColumn = static_cast<CondDBColumnLong*>(m_conddbtable[n_column]);
746 status = __getCell(n_column,n_row, aux, kLongLong, tmpColumn);
747 if (status == CDB_SUCCESS)
748 ndata = ToString(aux);
749 break;
750 }
751 case kFloat:
752 {
753 float aux;
754
755 CondDBColumnFloat *tmpColumn = static_cast<CondDBColumnFloat*>(m_conddbtable[n_column]);
756 status = __getCell(n_column,n_row, aux, kFloat, tmpColumn);
757 if (status == CDB_SUCCESS)
758 ndata = ToString(aux);
759 break;
760 }
761 case kDouble:
762 {
763 double aux;
764 CondDBColumnDouble *tmpColumn = static_cast<CondDBColumnDouble*>(m_conddbtable[n_column]);
765 status = __getCell(n_column,n_row,aux,kDouble, tmpColumn);
766 if (status == CDB_SUCCESS)
767 ndata = ToString(aux);
768 break;
769 }
770 //if the column is of the type array of *type* one should use the method with vector of strings
771 default:
772 return CDB_STRTOARRAY_ERROR;
773 }
774 }
775 }
776 else
777 return CDB_RANGE_ERROR;
778
779 return status;
780
781}
GenericDbTable::ToString
std::string ToString(const TYPE &t) const
Auxiliary function to convert any value to string.
Definition GenericDbTable.h:651
merge.status
status
Definition merge.py:16

◆ getCell() [19/24]

int GenericDbTable::getCell ( unsigned n_column,
unsigned n_row,
std::vector< double > & ndata ) const

This method gets a value from a cell in a column of vector of doubles.

Parameters
n_columnis the column number
n_rowis the row number
ndatais the reference to the valriable where the value will be returned
Returns
an error code

◆ getCell() [20/24]

int GenericDbTable::getCell ( unsigned n_column,
unsigned n_row,
std::vector< float > & ndata ) const

This method gets a value from a cell in a column of vectors of floats.

Parameters
n_columnis the column number
n_rowis the row number
ndatais the reference to the valriable where the value will be returned
Returns
an error code

◆ getCell() [21/24]

int GenericDbTable::getCell ( unsigned n_column,
unsigned n_row,
std::vector< int64 > & ndata ) const

This method gets a value from a cell in a column of vectors of long long ints (bigint in MySQL - 8bytes)

Parameters
n_columnis the column number
n_rowis the row number
ndatais the reference to the valriable where the value will be returned
Returns
an error code

Definition at line 801 of file GenericDbTable.cxx.

802{
803 CondDBColumnArrayLong *tmpColumn = static_cast<CondDBColumnArrayLong*>(m_conddbtable[n_column]);
804 return __getCell(n_column, n_row, ndata, kArrayLongLong, tmpColumn);
805}

◆ getCell() [22/24]

int GenericDbTable::getCell ( unsigned n_column,
unsigned n_row,
std::vector< long int > & ndata ) const

This method gets a value from a cell in a column of vectors of long ints (int in MySQL - 4bytes)

Parameters
n_columnis the column number
n_rowis the row number
ndatais the reference to the valriable where the value will be returned
Returns
an error code

Definition at line 789 of file GenericDbTable.cxx.

790{
791 CondDBColumnArrayInt *tmpColumn = static_cast<CondDBColumnArrayInt*>(m_conddbtable[n_column]);
792 return __getCell(n_column, n_row, ndata, kArrayInt, tmpColumn);
793}

◆ getCell() [23/24]

int GenericDbTable::getCell ( unsigned n_column,
unsigned n_row,
std::vector< short int > & ndata ) const

This method gets a value from a cell in a column of vectors of bools.

Parameters
n_columnis the column number
n_rowis the row number
ndatais the reference to the valriable where the value will be returned
Returns
an error code

Definition at line 795 of file GenericDbTable.cxx.

796{
797 CondDBColumnArrayBool *tmpColumn = static_cast<CondDBColumnArrayBool*>(m_conddbtable[n_column]);
798 return __getCell(n_column, n_row, ndata, kArrayBool, tmpColumn);
799}

◆ getCell() [24/24]

int GenericDbTable::getCell ( unsigned n_column,
unsigned n_row,
std::vector< std::string > & ndata ) const

This method gets a value from a cell in a column of vector of strings.

Parameters
n_columnis the column number
n_rowis the row number
ndatais the reference to the valriable where the value will be returned
Returns
an error code

Definition at line 813 of file GenericDbTable.cxx.

814{
815 CondDBColumnArrayString *tmpColumn = static_cast<CondDBColumnArrayString*>(m_conddbtable[n_column]);
816 return __getCell(n_column, n_row, ndata, kArrayString, tmpColumn);
817}

◆ getNames()

int GenericDbTable::getNames ( std::vector< std::string > & names) const

This method gets a vector containing the names of all columns in the table.

Parameters
namesis the reference to the vector returned
Returns
an error code

Definition at line 85 of file GenericDbTable.cxx.

86{
87 if (!m_isInitialized)
88 return CDB_NOT_INITIALIZED;
89
90 for (unsigned i = 0; i < m_conddbtable.size(); i++)
91 {
92 names.push_back(m_conddbtable[i]->name);
93 }
94
95 return 0;
96}

◆ getNull() [1/5]

int GenericDbTable::getNull ( unsigned n_column,
double & null ) const

Definition at line 286 of file GenericDbTable.cxx.

287{
288 if (!m_isInitialized)
289 return CDB_NOT_INITIALIZED;
290
291 if (m_conddbtable.size() > n_column)
292 if (m_conddbtable[n_column]->type == kDouble)
293 {
294 CondDBColumnDouble *tmpColumn = static_cast<CondDBColumnDouble*>(m_conddbtable[n_column]);
295 return __getNull(null, tmpColumn);
296 }
297 else if (m_conddbtable[n_column]->type == kArrayDouble)
298 {
299 vector<double> tmp;
300 CondDBColumnArrayDouble *tmpColumn = static_cast<CondDBColumnArrayDouble*>(m_conddbtable[n_column]);
301 __getNull(tmp, tmpColumn);
302 null = tmp[0];
303 return CDB_SUCCESS;
304 }
305 else
306 return CDB_TYPE_ERROR;
307 else
308 return CDB_RANGE_ERROR;
309}
GenericDbTable::__getNull
int __getNull(T &data, COLUMN *tmpColumn) const
Templated method for handling the null values.
Definition GenericDbTable.h:595

◆ getNull() [2/5]

int GenericDbTable::getNull ( unsigned n_column,
float & null ) const

Get Null value for column.

Definition at line 237 of file GenericDbTable.cxx.

238{
239 if (!m_isInitialized)
240 return CDB_NOT_INITIALIZED;
241
242 if (m_conddbtable.size() > n_column)
243 if (m_conddbtable[n_column]->type == kFloat)
244 {
245 CondDBColumnFloat *tmpColumn = static_cast<CondDBColumnFloat*>(m_conddbtable[n_column]);
246 return __getNull(null, tmpColumn);
247 }
248 else if ( m_conddbtable[n_column]->type == kArrayFloat)
249 {
250 vector<float> tmp;
251 CondDBColumnArrayFloat *tmpColumn = static_cast<CondDBColumnArrayFloat*>(m_conddbtable[n_column]);
252 __getNull(tmp, tmpColumn);
253 null=tmp[0];
254 return CDB_SUCCESS;
255 }
256 else
257 return CDB_TYPE_ERROR;
258 else
259 return CDB_RANGE_ERROR;
260}

◆ getNull() [3/5]

int GenericDbTable::getNull ( unsigned n_column,
int64 & null ) const

Definition at line 311 of file GenericDbTable.cxx.

312{
313 if (!m_isInitialized)
314 return CDB_NOT_INITIALIZED;
315
316 if (m_conddbtable.size() > n_column)
317 if (m_conddbtable[n_column]->type == kLongLong)
318 {
319 CondDBColumnLong *tmpColumn = static_cast<CondDBColumnLong*>(m_conddbtable[n_column]);
320 return __getNull(null, tmpColumn);
321 }
322 else if ( m_conddbtable[n_column]->type == kArrayLongLong)
323 {
324 vector<int64> tmp;
325 CondDBColumnArrayLong *tmpColumn = static_cast<CondDBColumnArrayLong*>(m_conddbtable[n_column]);
326 __getNull(tmp, tmpColumn);
327 null = tmp[0];
328 return CDB_SUCCESS;
329 }
330 else
331 return CDB_TYPE_ERROR;
332 else
333 return CDB_RANGE_ERROR;
334}

◆ getNull() [4/5]

int GenericDbTable::getNull ( unsigned n_column,
long int & null ) const

Definition at line 262 of file GenericDbTable.cxx.

263{
264 if (!m_isInitialized)
265 return CDB_NOT_INITIALIZED;
266
267 if (m_conddbtable.size() > n_column)
268 if (m_conddbtable[n_column]->type == kInt)
269 {
270 CondDBColumnInt *tmpColumn = static_cast<CondDBColumnInt*>(m_conddbtable[n_column]);
271 return __getNull(null, tmpColumn);
272 }
273 else if (m_conddbtable[n_column]->type == kArrayInt)
274 {
275 vector<long int> tmp;
276 CondDBColumnArrayInt *tmpColumn = static_cast<CondDBColumnArrayInt*>(m_conddbtable[n_column]);
277 __getNull(tmp, tmpColumn);
278 return CDB_SUCCESS;
279 }
280 else
281 return CDB_TYPE_ERROR;
282 else
283 return CDB_RANGE_ERROR;
284}

◆ getNull() [5/5]

int GenericDbTable::getNull ( unsigned n_column,
std::string & null ) const

Definition at line 137 of file GenericDbTable.cxx.

138{
139 if (!m_isInitialized)
140 return CDB_NOT_INITIALIZED;
141
142 if (m_conddbtable.size() > n_column)
143 {
144 switch (m_conddbtable[n_column]->type)
145 {
146 case kString:
147 {
148 CondDBColumnString *tmpColumn = static_cast<CondDBColumnString*>(m_conddbtable[n_column]);
149 return __getNull(null, tmpColumn);
150 }
151 case kArrayString:
152 {
153 vector<string> tmp;
154 CondDBColumnArrayString *tmpColumn = static_cast<CondDBColumnArrayString*>(m_conddbtable[n_column]);
155 __getNull(tmp, tmpColumn);
156 null = tmp[0];
157 return CDB_SUCCESS;
158 }
159 case kFloat:
160 {
161 float tmp;
162 CondDBColumnFloat *tmpColumn = static_cast<CondDBColumnFloat*>(m_conddbtable[n_column]);
163 __getNull(tmp, tmpColumn);
164 null = ToString<float>(tmp);
165 return CDB_SUCCESS;
166 }
167 case kArrayFloat:
168 {
169 vector<float> tmp;
170 CondDBColumnArrayFloat *tmpColumn = static_cast<CondDBColumnArrayFloat*>(m_conddbtable[n_column]);
171 __getNull(tmp, tmpColumn);
172 null = ToString<float>(tmp[0]);
173 return CDB_SUCCESS;
174 }
175 case kInt:
176 {
177 long int tmp;
178 CondDBColumnInt *tmpColumn = static_cast<CondDBColumnInt*>(m_conddbtable[n_column]);
179 __getNull(tmp, tmpColumn);
180 null = ToString<float>(tmp);
181 return CDB_SUCCESS;
182 }
183 case kArrayInt:
184 {
185 vector<long int> tmp;
186 CondDBColumnArrayInt *tmpColumn = static_cast<CondDBColumnArrayInt*>(m_conddbtable[n_column]);
187 __getNull(tmp, tmpColumn);
188 null = ToString(tmp[0]);
189 return CDB_SUCCESS;
190 }
191 case kDouble:
192 {
193 double tmp;
194 CondDBColumnDouble *tmpColumn = static_cast<CondDBColumnDouble*>(m_conddbtable[n_column]);
195 __getNull(tmp, tmpColumn);
196 null = ToString(tmp);
197 return CDB_SUCCESS;
198 }
199 case kArrayDouble:
200 {
201 vector<double> tmp;
202 CondDBColumnArrayDouble *tmpColumn = static_cast<CondDBColumnArrayDouble*>(m_conddbtable[n_column]);
203 __getNull(tmp, tmpColumn);
204 null = ToString(tmp[0]);
205 return CDB_SUCCESS;
206 }
207 case kLongLong:
208 {
209 int64 tmp;
210 CondDBColumnLong *tmpColumn = static_cast<CondDBColumnLong*>(m_conddbtable[n_column]);
211 __getNull(tmp, tmpColumn);
212 null = ToString(tmp);
213 return CDB_SUCCESS;
214 }
215 case kArrayLongLong:
216 {
217 vector<int64> tmp;
218 CondDBColumnArrayLong *tmpColumn = static_cast<CondDBColumnArrayLong*>(m_conddbtable[n_column]);
219 __getNull(tmp, tmpColumn);
220 null = ToString(tmp[0]);
221 return CDB_SUCCESS;
222 }
223 case kBool:
224 case kArrayBool:
225 {
226 null=ToString(-1);
227 return CDB_SUCCESS;
228 }
229 default:
230 return CDB_TYPE_ERROR;
231 }
232 }
233 else
234 return CDB_RANGE_ERROR;
235}
int64
long long int64
Definition GenericDbTable.h:17

◆ getNumColumns()

unsigned GenericDbTable::getNumColumns ( ) const
inline

Returns the number of columns in the table.

The user must know if all rows reserved are already assigned with values

Returns
number of rows reserved.

Definition at line 579 of file GenericDbTable.h.

579{return m_conddbtable.size();}

◆ getNumRows()

unsigned GenericDbTable::getNumRows ( ) const
inline

Returns the number of rows RESERVED in the table.

The user must know if all rows reserved are already assigned with values

Returns
number of rows reserved.

Definition at line 571 of file GenericDbTable.h.

571{return m_numRows;}

◆ getRow()

int GenericDbTable::getRow ( unsigned rowNumber,
std::vector< std::string > & values ) const

This method returns a vector of strings with allelements in a row In case the cell has an array the first string has the number of elements (following strings) belonging to the array.

Parameters
rowNumberis the number of the row
valuesis the string that will be returned with the row elements
Returns
an error code that is to be defined yet

Definition at line 1597 of file GenericDbTable.cxx.

1598{
1599 if (n_row < m_numRows)
1600 {
1601 for (unsigned i =0; i<m_conddbtable.size(); i++)
1602 {
1603 switch(m_conddbtable[i]->type)
1604 {
1605 case kInt:
1606 {
1607 long int tmp;
1608 getCell(i,n_row, tmp);
1609 values.push_back(ToString<long int>(tmp));
1610 break;
1611 }
1612 case kBool:
1613 {
1614 short int tmp;
1615 getCell(i,n_row, tmp);
1616 values.push_back(ToString<short int>(tmp));
1617 break;
1618 }
1619 case kLongLong:
1620 {
1621 int64 tmp;
1622 getCell(i,n_row, tmp);
1623 values.push_back(ToString<int64>(tmp));
1624 break;
1625 }
1626 case kFloat:
1627 {
1628 float tmp;
1629 getCell(i,n_row, tmp);
1630 values.push_back(ToString<float>(tmp));
1631 break;
1632
1633 }
1634 case kString:
1635 {
1636 string tmp;
1637 getCell(i,n_row, tmp);
1638 values.push_back(ToString<string>(tmp));
1639 break;
1640
1641 }
1642 case kDouble:
1643 {
1644 double tmp;
1645 getCell(i,n_row, tmp);
1646 values.push_back(ToString<double>(tmp));
1647 break;
1648
1649 }
1650 case kArrayInt:
1651 {
1652 vector<long int> tmp;
1653 getCell(i,n_row, tmp);
1654 int size = tmp.size();
1655 values.push_back(ToString<int>(size));
1656 while(size)
1657 {
1658 values.push_back(ToString<long int>(tmp[size-1]));
1659 size--;
1660 }
1661 break;
1662
1663 }
1664 case kArrayBool:
1665 {
1666 vector<short int> tmp;
1667 getCell(i,n_row, tmp);
1668 int size = tmp.size();
1669 values.push_back(ToString<int>(size));
1670 while(size)
1671 {
1672 values.push_back(ToString<short int>(tmp[size-1]));
1673 size--;
1674 }
1675 break;
1676
1677 }
1678 case kArrayLongLong:
1679 {
1680 vector<int64> tmp;
1681 getCell(i,n_row, tmp);
1682 int size = tmp.size();
1683 values.push_back(ToString<int>(size));
1684 while(size)
1685 {
1686 values.push_back(ToString<int64>(tmp[size-1]));
1687 size--;
1688 }
1689 break;
1690
1691 }
1692 case kArrayFloat:
1693 {
1694 vector<float> tmp;
1695 getCell(i,n_row, tmp);
1696 int size = tmp.size();
1697 values.push_back(ToString<int>(size));
1698 while(size)
1699 {
1700 values.push_back(ToString<float>(tmp[size-1]));
1701 size--;
1702 }
1703 break;
1704
1705 }
1706 case kArrayString:
1707 {
1708 vector<string> tmp;
1709 getCell(i,n_row, tmp);
1710 int size = tmp.size();
1711 values.push_back(ToString<int>(size));
1712 while(size)
1713 {
1714 values.push_back(tmp[size-1]);
1715 size--;
1716 }
1717 break;
1718 }
1719 case kArrayDouble:
1720 {
1721 vector<double> tmp;
1722 getCell(i,n_row, tmp);
1723 int size = tmp.size();
1724 values.push_back(ToString<int>(size));
1725 while(size)
1726 {
1727 values.push_back(ToString<double>(tmp[size-1]));
1728 size--;
1729 }
1730 break;
1731 }
1732 default: return CDB_TYPE_ERROR;
1733 }
1734 }
1735
1736 }
1737 else
1738 return CDB_RANGE_ERROR;
1739// sucess!
1740 return CDB_SUCCESS;
1741}

◆ getRowID()

int GenericDbTable::getRowID ( std::string & pID) const

This method returns, for a given ID, the row number.

In case that this table does not have id's returns -1

Parameters
pIDis the ID that must be searched
Returns
the row number for this ID

Definition at line 111 of file GenericDbTable.cxx.

112{
113 std::vector<std::string> names;
114 unsigned int ncolumn = 0;
115
116 if (getNames(names) != CDB_NOT_INITIALIZED) { //success
117 ncolumn = std::count_if(names.begin(),names.end(), [](const auto & s){return s != "Id";} );
118
119 // if the table does not have id's
120 if (ncolumn == names.size())
121 return -1;
122
123 CondDBColumnString *dcolumn = static_cast<CondDBColumnString*>(m_conddbtable[ncolumn]);
124
125 for (unsigned int i = 0; i < dcolumn->column.size(); i++) {
126 if (dcolumn->column[i] == pID) {
127 return i;
128 }
129 }
130 }
131 // if the execution is here it means that the id doesn't exist in the column
132 return -1;
133
134}
GenericDbTable::getNames
int getNames(std::vector< std::string > &names) const
This method gets a vector containing the names of all columns in the table.
Definition GenericDbTable.cxx:85

◆ getTypes()

int GenericDbTable::getTypes ( std::vector< dataTypes > & types) const

This method gets a vector containing the data types of all columns in the table.

Parameters
typesis the reference to the vector returned
Returns
an error code

Definition at line 98 of file GenericDbTable.cxx.

99{
100 if (!m_isInitialized)
101 return CDB_NOT_INITIALIZED;
102
103 for (unsigned i = 0; i < m_conddbtable.size(); i++)
104 {
105 types.push_back(m_conddbtable[i]->type);
106 }
107 return 0;
108}
types
static const std::vector< std::string > types
Definition MuonTriggerSFFilesTest.cxx:20

◆ Initialize()

void GenericDbTable::Initialize ( unsigned n_columns,
int n_rows = 0 )

This method initializes a table created by the default constructor If the table had the number of columns already defined this does nothing.

Parameters
n_columnsis the number of columns of this table
n_rowsis the number of rows to allocate (OPTIONAL)

Definition at line 61 of file GenericDbTable.cxx.

62{
63 unsigned i;
64
65 if (m_conddbtable.size() > 0 || m_isInitialized == true)
66 return;
67
68 for (i=0;i<n_columns; i++)
69 m_conddbtable.push_back(new CondDBColumn);
70
71 for (i = 0; i<m_conddbtable.size(); i++ )
72 {
73 m_conddbtable[i]->initialized = false;
74 m_conddbtable[i]->type = kNull;
75 }
76
77 if (n_rows)
78 {
79 resize(n_rows);
80// status = vector<CondDBStatus>(n_rows,untouched);
81 }
82}

◆ resize()

void GenericDbTable::resize ( int num_rows)

Reserves more rows on the table.

This method must be called at each time that one wants to insert new data on the table reserving only the number of rows that will be used!

Parameters
num_rowsis the amount of rows that must be reserved in the table

Definition at line 1587 of file GenericDbTable.cxx.

1588{
1589 m_numRows += num_rows;
1590}

◆ setCell() [1/12]

int GenericDbTable::setCell ( unsigned n_column,
unsigned n_row,
const double ndata )

This method changes a value from a cell in a column of doubles.

Parameters
n_columnis the column number
n_rowis the row number
ndatais the new value to be assigned
Returns
an error code

Definition at line 1007 of file GenericDbTable.cxx.

1008{
1009 CondDBColumnDouble *tmpColumn = static_cast<CondDBColumnDouble*>(m_conddbtable[n_column]);
1010 return __setCell(n_column, n_row, ndata, kDouble, tmpColumn);
1011}
GenericDbTable::__setCell
int __setCell(unsigned n_column, unsigned n_row, const T &ndata, dataTypes type, COLUMN *tmpColumn)
Templated method that set's the data in a specified cell This is the method that does the real work.
Definition GenericDbTable.cxx:1788

◆ setCell() [2/12]

int GenericDbTable::setCell ( unsigned n_column,
unsigned n_row,
const float ndata )

This method changes a value from a cell in a column of floats.

Parameters
n_columnis the column number
n_rowis the row number
ndatais the new value to be assigned
Returns
an error code

Definition at line 902 of file GenericDbTable.cxx.

903{
904 CondDBColumnFloat *tmpColumn = static_cast<CondDBColumnFloat*>(m_conddbtable[n_column]);
905 return __setCell(n_column, n_row, ndata, kFloat, tmpColumn);
906}

◆ setCell() [3/12]

int GenericDbTable::setCell ( unsigned n_column,
unsigned n_row,
const int64 ndata )

This method changes a value from a cell in a column of long long ints.

Parameters
n_columnis the column number
n_rowis the row number
ndatais the new value to be assigned
Returns
an error code

Definition at line 896 of file GenericDbTable.cxx.

897{
898 CondDBColumnLong *tmpColumn = static_cast<CondDBColumnLong*>(m_conddbtable[n_column]);
899 return __setCell(n_column, n_row, ndata, kLongLong, tmpColumn);
900}

◆ setCell() [4/12]

int GenericDbTable::setCell ( unsigned n_column,
unsigned n_row,
const long int ndata )

This method changes a value from a cell in a column of long ints.

Parameters
n_columnis the column number
n_rowis the row number
ndatais the new value to be assigned
Returns
an error code

Definition at line 884 of file GenericDbTable.cxx.

885{
886 CondDBColumnInt *tmpColumn = static_cast<CondDBColumnInt*>(m_conddbtable[n_column]);
887 return __setCell(n_column, n_row, ndata, kInt, tmpColumn);
888}

◆ setCell() [5/12]

int GenericDbTable::setCell ( unsigned n_column,
unsigned n_row,
const short int ndata )

set data methods

These methods allow to chage a value in a specified cell This method changes a value from a cell in a column of long ints

Parameters
n_columnis the column number
n_rowis the row number
ndatais the new value to be assigned
Returns
an error code

Definition at line 890 of file GenericDbTable.cxx.

891{
892 CondDBColumnBool *tmpColumn = static_cast<CondDBColumnBool*>(m_conddbtable[n_column]);
893 return __setCell(n_column, n_row, ndata, kBool, tmpColumn);
894}

◆ setCell() [6/12]

int GenericDbTable::setCell ( unsigned n_column,
unsigned n_row,
const std::string & ndata )

This method changes a value from a cell in a column of strings.

Parameters
n_columnis the column number
n_rowis the row number
ndatais the new value to be assigned
Returns
an error code

Definition at line 908 of file GenericDbTable.cxx.

909{
910
911 if (!m_isInitialized)
912 return CDB_NOT_INITIALIZED;
913
914 if ((m_numRows > n_row) && (m_conddbtable.size() > n_column))
915 {
916 if (m_conddbtable[n_column]->type == kString)
917 {
918 CondDBColumnString *tmpColumn = static_cast<CondDBColumnString*>(m_conddbtable[n_column]);
919 __setCell(n_column, n_row, ndata, kString, tmpColumn);
920 }
921 else
922 {
923 switch(m_conddbtable[n_column]->type)
924 {
925 case kInt:
926 {
927 if (ndata=="NULL")
928 {
929 CondDBColumnInt *tmpColumn = static_cast<CondDBColumnInt*>(m_conddbtable[n_column]);
930 __setCell(n_column, n_row, tmpColumn->column[0], kInt, tmpColumn);
931 }
932 else
933 {
934 CondDBColumnInt *tmpColumn = static_cast<CondDBColumnInt*>(m_conddbtable[n_column]);
935 __setCell(n_column, n_row, atol(ndata.c_str()), kInt, tmpColumn);
936 }
937 break;
938 }
939 case kBool:
940 {
941 if (ndata=="NULL")
942 {
943 CondDBColumnBool *tmpColumn = static_cast<CondDBColumnBool*>(m_conddbtable[n_column]);
944 __setCell(n_column,n_row, tmpColumn->column[0], kBool, tmpColumn);
945
946 }
947 else
948 {
949 CondDBColumnBool *tmpColumn = static_cast<CondDBColumnBool*>(m_conddbtable[n_column]);
950 __setCell(n_column, n_row, atoi(ndata.c_str()), kBool, tmpColumn);
951 }
952 break;
953 }
954 case kLongLong:
955 {
956 if (ndata=="NULL")
957 {
958 CondDBColumnLong *tmpColumn = static_cast<CondDBColumnLong*>(m_conddbtable[n_column]);
959 __setCell(n_column,n_row, tmpColumn->column[0], kLongLong, tmpColumn);
960 }
961 else
962 {
963 CondDBColumnLong *tmpColumn = static_cast<CondDBColumnLong*>(m_conddbtable[n_column]);
964 __setCell(n_column,n_row, atoi64(ndata.c_str()), kLongLong, tmpColumn);
965 }
966 break;
967 }
968 case kFloat:
969 {
970 if (ndata=="NULL")
971 {
972 CondDBColumnFloat *tmpColumn = static_cast<CondDBColumnFloat*>(m_conddbtable[n_column]);
973 __setCell(n_column,n_row, tmpColumn->column[0], kFloat, tmpColumn);
974 }
975 else
976 {
977 CondDBColumnFloat *tmpColumn = static_cast<CondDBColumnFloat*>(m_conddbtable[n_column]);
978 __setCell(n_column,n_row, strtod(ndata.c_str(), (char **)NULL), kFloat, tmpColumn);
979 }
980 break;
981 }
982 case kDouble:
983 {
984 if (ndata=="NULL")
985 {
986 CondDBColumnDouble *tmpColumn = static_cast<CondDBColumnDouble*>(m_conddbtable[n_column]);
987 __setCell(n_column,n_row, tmpColumn->column[0],kDouble, tmpColumn);
988 }
989 else
990 {
991 CondDBColumnDouble *tmpColumn = static_cast<CondDBColumnDouble*>(m_conddbtable[n_column]);
992 __setCell(n_column,n_row,strtod(ndata.c_str(), (char **)NULL),kDouble, tmpColumn);
993 }
994 break;
995 }
996 //if the column is of the type array of *type* one should use the method with vector of strings
997 default:
998 return CDB_STRTOARRAY_ERROR;
999 }
1000 }
1001 }
1002 else
1003 return CDB_RANGE_ERROR;
1004 return CDB_SUCCESS;
1005}
atoi64
#define atoi64(x)
Definition GenericDbTable.cxx:20
CxxUtils::atoi
int atoi(std::string_view str)
Helper functions to unpack numbers decoded in string into integers and doubles The strings are requir...
Definition Control/CxxUtils/Root/StringUtils.cxx:85

◆ setCell() [7/12]

int GenericDbTable::setCell ( unsigned n_column,
unsigned n_row,
const std::vector< double > & ndata )

This method changes a value from a cell in a column of vectors of doubles.

Parameters
n_columnis the column number
n_rowis the row number
ndatais the new array to be assigned
Returns
an error code

◆ setCell() [8/12]

int GenericDbTable::setCell ( unsigned n_column,
unsigned n_row,
const std::vector< float > & ndata )

This method changes a value from a cell in a column of vectors of floats.

Parameters
n_columnis the column number
n_rowis the row number
ndatais the new array to be assigned
Returns
an error code

◆ setCell() [9/12]

int GenericDbTable::setCell ( unsigned n_column,
unsigned n_row,
const std::vector< int64 > & ndata )

This method changes a value from a cell in a column of vectors of long long ints.

Parameters
n_columnis the column number
n_rowis the row number
ndatais the new array to be assigned
Returns
an error code

Definition at line 1025 of file GenericDbTable.cxx.

1026{
1027 CondDBColumnArrayLong *tmpColumn = static_cast<CondDBColumnArrayLong*>(m_conddbtable[n_column]);
1028 return __setCell(n_column, n_row, ndata, kArrayLongLong, tmpColumn);
1029}

◆ setCell() [10/12]

int GenericDbTable::setCell ( unsigned n_column,
unsigned n_row,
const std::vector< long int > & ndata )

This method changes a value from a cell in a column of vectors of long ints.

Parameters
n_columnis the column number
n_rowis the row number
ndatais the new array to be assigned
Returns
an error code

Definition at line 1019 of file GenericDbTable.cxx.

1020{
1021 CondDBColumnArrayInt *tmpColumn = static_cast<CondDBColumnArrayInt*>(m_conddbtable[n_column]);
1022 return __setCell(n_column, n_row, ndata, kArrayInt, tmpColumn);
1023}

◆ setCell() [11/12]

int GenericDbTable::setCell ( unsigned n_column,
unsigned n_row,
const std::vector< short int > & ndata )

This method changes a value from a cell in a column of vectors of bools.

Parameters
n_columnis the column number
n_rowis the row number
ndatais the new array to be assigned
Returns
an error code

Definition at line 1013 of file GenericDbTable.cxx.

1014{
1015 CondDBColumnArrayBool *tmpColumn = static_cast<CondDBColumnArrayBool*>(m_conddbtable[n_column]);
1016 return __setCell(n_column, n_row, ndata, kArrayBool, tmpColumn);
1017}

◆ setCell() [12/12]

int GenericDbTable::setCell ( unsigned n_column,
unsigned n_row,
const std::vector< std::string > & ndata )

This method changes a value from a cell in a column of vectors of strings.

Parameters
n_columnis the column number
n_rowis the row number
ndatais the new array to be assigned
Returns
an error code

Definition at line 1045 of file GenericDbTable.cxx.

1046{
1047
1048 if (!m_isInitialized)
1049 return CDB_NOT_INITIALIZED;
1050
1051 if ((m_numRows > n_row) && (m_conddbtable.size() > n_column))
1052 {
1053 if (m_conddbtable[n_column]->type == kArrayString)
1054 {
1055 CondDBColumnArrayString *tmpColumn = static_cast<CondDBColumnArrayString*>(m_conddbtable[n_column]);
1056 return __setCell(n_column, n_row, ndata, kArrayString, tmpColumn);
1057// static_cast<CondDBColumnArrayString*>(m_conddbtable[n_column])->column[n_row+1] = ndata;
1058 }
1059 else
1060 {
1061 switch(m_conddbtable[n_column]->type)
1062 {
1063 case kArrayInt:
1064 {
1065 vector<long int> tmp;
1066 for (unsigned i=0; i<ndata.size(); i++)
1067 {
1068 if (ndata[i]=="NULL")
1069 {
1070 long int null;
1071 getNull(n_column, null);
1072 tmp.push_back(null);
1073 }
1074 else
1075 tmp.push_back(atol(ndata[i].c_str()));
1076 }
1077 CondDBColumnArrayInt *tmpColumn = static_cast<CondDBColumnArrayInt*>(m_conddbtable[n_column]);
1078 return __setCell(n_column, n_row, tmp, kArrayInt, tmpColumn);
1079 break;
1080 }
1081 case kArrayBool:
1082 {
1083 vector<short int> tmp;
1084 for (unsigned i=0; i<ndata.size(); i++)
1085 {
1086 if (ndata[i]=="NULL")
1087 {
1088 tmp.push_back(-1);
1089 }
1090 else
1091 tmp.push_back(atoi(ndata[i].c_str()));
1092 }
1093 CondDBColumnArrayBool *tmpColumn = static_cast<CondDBColumnArrayBool*>(m_conddbtable[n_column]);
1094 return __setCell(n_column, n_row, tmp, kArrayBool, tmpColumn);
1095 break;
1096 }
1097 case kArrayLongLong:
1098 {
1099 vector<int64> tmp;
1100 for (unsigned i=0; i<ndata.size(); i++)
1101 {
1102 if (ndata[i]=="NULL")
1103 {
1104 int64 null;
1105 getNull(n_column, null);
1106 tmp.push_back(null);
1107 }
1108 else
1109
1110 tmp.push_back(atoi64(ndata[i].c_str()));
1111 }
1112 CondDBColumnArrayLong *tmpColumn = static_cast<CondDBColumnArrayLong*>(m_conddbtable[n_column]);
1113 return __setCell(n_column, n_row, tmp, kArrayLongLong, tmpColumn);
1114 break;
1115 }
1116 case kArrayFloat:
1117 {
1118 vector<float> tmp;
1119 for (unsigned i=0; i<ndata.size(); i++)
1120 {
1121 if (ndata[i]=="NULL")
1122 {
1123 float null;
1124 getNull(n_column, null);
1125 tmp.push_back(null);
1126 }
1127 else
1128 tmp.push_back(atof(ndata[i].c_str()));
1129 }
1130 CondDBColumnArrayFloat *tmpColumn = static_cast<CondDBColumnArrayFloat*>(m_conddbtable[n_column]);
1131 return __setCell(n_column, n_row, tmp, kArrayFloat, tmpColumn);
1132 break;
1133 }
1134 case kArrayDouble:
1135 {
1136 vector<double> tmp;
1137 for (unsigned i=0; i<ndata.size(); i++)
1138 {
1139 if (ndata[i]=="NULL")
1140 {
1141 double null;
1142 getNull(n_column, null);
1143 tmp.push_back(null);
1144 }
1145 else
1146 tmp.push_back(strtod(ndata[i].c_str(), (char**)NULL));
1147 }
1148 CondDBColumnArrayDouble *tmpColumn = static_cast<CondDBColumnArrayDouble*>(m_conddbtable[n_column]);
1149 return __setCell(n_column, n_row, tmp, kArrayDouble, tmpColumn);
1150 break;
1151 }
1152 //if the column is of the type array of *type* one should use the method with vector of strings
1153 default:
1154 return CDB_STRTOARRAY_ERROR;
1155 }
1156 }
1157 }
1158 else
1159 return CDB_RANGE_ERROR;
1160 return CDB_SUCCESS;
1161}
GenericDbTable::getNull
int getNull(unsigned n_column, float &null) const
Get Null value for column.
Definition GenericDbTable.cxx:237
CxxUtils::atof
double atof(std::string_view str)
Converts a string into a double / float.
Definition Control/CxxUtils/Root/StringUtils.cxx:91

◆ setColumndata() [1/12]

int GenericDbTable::setColumndata ( unsigned n_column,
const std::vector< double > & data )

Insert a subset in a column of doubles.

Parameters
n_columnRefers to the column number
datarefers to the values to be appended in the column
Returns
the number of values inserted
See also
getNames(); getTypes()

◆ setColumndata() [2/12]

int GenericDbTable::setColumndata ( unsigned n_column,
const std::vector< float > & data )

Insert a subset in a column of floats.

Parameters
n_columnRefers to the column number
datarefers to the values to be appended in the column
Returns
the number of values inserted
See also
getNames(); getTypes()

◆ setColumndata() [3/12]

int GenericDbTable::setColumndata ( unsigned n_column,
const std::vector< int64 > & data )

Insert a subset in a column of long long ints.

Parameters
n_columnRefers to the column number
datarefers to the values to be appended in the column
Returns
the number of values inserted
See also
getNames(); getTypes()

Definition at line 1178 of file GenericDbTable.cxx.

1179{
1180 CondDBColumnLong *tmpColumn = static_cast<CondDBColumnLong*>(m_conddbtable[n_column]);
1181 return __setColumnData(n_column, data, kLongLong, tmpColumn);
1182}
GenericDbTable::__setColumnData
int __setColumnData(unsigned n_column, T &data, dataTypes type, COLUMN *tmpColumn)
Templated method that set's portions of data in a specified column This method is deprecated and henc...
Definition GenericDbTable.cxx:1825

◆ setColumndata() [4/12]

int GenericDbTable::setColumndata ( unsigned n_column,
const std::vector< long int > & data )

Insert a subset in a column of long ints.

Parameters
n_columnRefers to the column number
datarefers to the values to be appended in the column
Returns
the number of values inserted
See also
getNames(); getTypes()

Definition at line 1172 of file GenericDbTable.cxx.

1173{
1174 CondDBColumnInt *tmpColumn = static_cast<CondDBColumnInt*>(m_conddbtable[n_column]);
1175 return __setColumnData(n_column, data, kInt, tmpColumn);
1176}

◆ setColumndata() [5/12]

int GenericDbTable::setColumndata ( unsigned n_column,
const std::vector< short int > & data )

The following methods allow to insert in the columns a group of values.

The values are passed in a vector. In case that there are not enougth rows reserved to insert the values there will be only inserted data until all rows are filled and return the number of values from the vector passed. Insert a subset in a column of bools

Parameters
n_columnRefers to the column number
datarefers to the values to be appended in the column
Returns
the number of values inserted
See also
getNames(); getTypes()

Definition at line 1184 of file GenericDbTable.cxx.

1185{
1186 CondDBColumnBool *tmpColumn = static_cast<CondDBColumnBool*>(m_conddbtable[n_column]);
1187 return __setColumnData(n_column, data, kBool, tmpColumn);
1188}

◆ setColumndata() [6/12]

int GenericDbTable::setColumndata ( unsigned n_column,
const std::vector< std::string > & data )

Insert a subset in a column of strings.

Parameters
n_columnRefers to the column number
datarefers to the values to be appended in the column
Returns
the number of values inserted
See also
getNames(); getTypes()

Definition at line 1196 of file GenericDbTable.cxx.

1197{
1198
1199 if (!m_isInitialized)
1200 return CDB_NOT_INITIALIZED;
1201
1202 unsigned index = 0;
1203 if (n_column < m_conddbtable.size())
1204 {
1205 if (m_conddbtable[n_column]->type == kString)
1206 {
1207 CondDBColumnString* tmpColumn = static_cast<CondDBColumnString*>(m_conddbtable[n_column]);
1208 while((tmpColumn->column.size() < m_numRows+1) && (index < data.size()))
1209 {
1210 tmpColumn->column.push_back(data[index]);
1211 index++;
1212 }
1213 return index;
1214 }
1215 else
1216 {
1217// If the data type is not string we can convert the string to the corresponding type
1218 switch(m_conddbtable[n_column]->type)
1219 {
1220//if the column data type is some kind of array it will be assumed that all values belong to a single cell thus returning 1(cell)
1221 case kArrayInt:
1222 {
1223 vector<long int> tmp;
1224 for (unsigned i=0; i<data.size(); i++)
1225 {
1226 if (data[i]=="NULL")
1227 {
1228 long int null;
1229 getNull(n_column, null);
1230 tmp.push_back(null);
1231 }
1232 else
1233 tmp.push_back(atol(data[i].c_str()));
1234 }
1235 index= setColumndata(n_column, tmp);
1236 break;
1237 }
1238 case kArrayBool:
1239 {
1240 vector<short int> tmp;
1241 for (unsigned i=0; i<data.size(); i++)
1242 {
1243 if (data[i]=="NULL")
1244 {
1245 short int null = -1;
1246 tmp.push_back(null);
1247 }
1248 else
1249 tmp.push_back(atoi(data[i].c_str()));
1250 }
1251 index = setColumndata(n_column, tmp);
1252 break;
1253 }
1254 case kArrayLongLong:
1255 {
1256 vector<int64> tmp;
1257 for (unsigned i=0; i<data.size(); i++)
1258 {
1259 if (data[i]=="NULL")
1260 {
1261 int64 null;
1262 getNull(n_column, null);
1263 tmp.push_back(null);
1264 }
1265 else
1266 tmp.push_back(atoi64(data[i].c_str()));
1267 }
1268 index = setColumndata(n_column, tmp);
1269 break;
1270 }
1271 case kArrayFloat:
1272 {
1273 vector<float> tmp;
1274 for (unsigned i=0; i<data.size(); i++)
1275 {
1276 if (data[i]=="NULL")
1277 {
1278 float null;
1279 getNull(n_column, null);
1280 tmp.push_back(null);
1281 }
1282 else
1283 tmp.push_back(atof(data[i].c_str()));
1284 }
1285 index = setColumndata(n_column, tmp);
1286 break;
1287 }
1288 case kArrayDouble:
1289 {
1290 vector<double> tmp;
1291 for (unsigned i=0; i<data.size(); i++)
1292 {
1293 if (data[i]=="NULL")
1294 {
1295 double null;
1296 getNull(n_column, null);
1297 tmp.push_back(null);
1298 }
1299 else
1300 tmp.push_back(strtod(data[i].c_str(), (char**)NULL));
1301 }
1302 index = setColumndata(n_column, tmp);
1303 break;
1304 }
1305//If the column data type is not any array it will be inserted a value in each row!
1306 case kInt:
1307 {
1308 vector<long int> tmp;
1309 for (unsigned i=0; i<data.size(); i++)
1310 {
1311 if (data[i]=="NULL")
1312 {
1313 long int null;
1314 getNull(n_column, null);
1315 tmp.push_back(null);
1316 }
1317 else
1318 tmp.push_back(atol(data[i].c_str()));
1319 }
1320 index = setColumndata(n_column, tmp);
1321 break;
1322 }
1323 case kBool:
1324 {
1325 vector<short int> tmp;
1326 for (unsigned i=0; i<data.size(); i++)
1327 {
1328 if (data[i]=="NULL")
1329 {
1330 // for bool the null value is -1 (not editable by user)
1331 short int null = -1;
1332 tmp.push_back(null);
1333 }
1334 else
1335 tmp.push_back(atoi(data[i].c_str()));
1336 }
1337 index = setColumndata(n_column, tmp);
1338 break;
1339 }
1340 case kLongLong:
1341 {
1342 vector<int64> tmp;
1343 for (unsigned i=0; i<data.size(); i++)
1344 {
1345 if (data[i]=="NULL")
1346 {
1347 int64 null;
1348 getNull(n_column, null);
1349 tmp.push_back(null);
1350 }
1351 else
1352 tmp.push_back(atoi64(data[i].c_str()));
1353 }
1354 index = setColumndata(n_column, tmp);
1355 break;
1356 }
1357 case kFloat:
1358 {
1359 vector<float> tmp;
1360 for (unsigned i=0; i<data.size(); i++)
1361 {
1362 if (data[i]=="NULL")
1363 {
1364 float null;
1365 getNull(n_column, null);
1366 tmp.push_back(null);
1367 }
1368 else
1369 tmp.push_back(atof(data[i].c_str()));
1370 }
1371 index = setColumndata(n_column, tmp);
1372 break;
1373 }
1374 case kDouble:
1375 {
1376 vector<double> tmp;
1377 for (unsigned i=0; i<data.size(); i++)
1378 {
1379 if (data[i]=="NULL")
1380 {
1381 double null;
1382 getNull(n_column, null);
1383 tmp.push_back(null);
1384 }
1385 else
1386 tmp.push_back(strtod(data[i].c_str(), (char**)NULL));
1387 }
1388 index = setColumndata(n_column, tmp);
1389 break;
1390 }
1391 default:
1392 return CDB_STRTOARRAY_ERROR;
1393 }
1394
1395 return index;
1396 }
1397 }
1398 else
1399 return CDB_RANGE_ERROR;
1400}
GenericDbTable::setColumndata
int setColumndata(unsigned n_column, const std::vector< short int > &data)
The following methods allow to insert in the columns a group of values.
Definition GenericDbTable.cxx:1184

◆ setColumndata() [7/12]

int GenericDbTable::setColumndata ( unsigned n_column,
const std::vector< std::vector< double > > & data )

Insert a subset in a column of vectors of doubles.

Parameters
n_columnRefers to the column number
datarefers to the values to be appended in the column
Returns
the number of values inserted
See also
getNames(); getTypes()

◆ setColumndata() [8/12]

int GenericDbTable::setColumndata ( unsigned n_column,
const std::vector< std::vector< float > > & data )

Insert a subset in a column of vectors of floats.

Parameters
n_columnRefers to the column number
datarefers to the values to be appended in the column
Returns
the number of values inserted
See also
getNames(); getTypes()

◆ setColumndata() [9/12]

int GenericDbTable::setColumndata ( unsigned n_column,
const std::vector< std::vector< int64 > > & data )

Insert a subset in a column of vectors of long long ints.

Parameters
n_columnRefers to the column number
datarefers to the values to be appended in the column
Returns
the number of values inserted
See also
getNames(); getTypes()

Definition at line 1414 of file GenericDbTable.cxx.

1415{
1416 CondDBColumnArrayLong *tmpColumn = static_cast<CondDBColumnArrayLong*>(m_conddbtable[n_column]);
1417 return __setColumnData(n_column, data, kArrayLongLong, tmpColumn);
1418}

◆ setColumndata() [10/12]

int GenericDbTable::setColumndata ( unsigned n_column,
const std::vector< std::vector< long int > > & data )

Insert a subset in a column of vectors of long ints.

Parameters
n_columnRefers to the column number
datarefers to the values to be appended in the column
Returns
the number of values inserted
See also
getNames(); getTypes()

Definition at line 1408 of file GenericDbTable.cxx.

1409{
1410 CondDBColumnArrayInt *tmpColumn = static_cast<CondDBColumnArrayInt*>(m_conddbtable[n_column]);
1411 return __setColumnData(n_column, data, kArrayInt, tmpColumn);
1412}

◆ setColumndata() [11/12]

int GenericDbTable::setColumndata ( unsigned n_column,
const std::vector< std::vector< short int > > & data )

Insert a subset in a column of vectors of bools.

Parameters
n_columnRefers to the column number
datarefers to the values to be appended in the column
Returns
the number of values inserted
See also
getNames(); getTypes()

Definition at line 1420 of file GenericDbTable.cxx.

1421{
1422 CondDBColumnArrayBool *tmpColumn = static_cast<CondDBColumnArrayBool*>(m_conddbtable[n_column]);
1423 return __setColumnData(n_column, data, kArrayBool, tmpColumn);
1424}

◆ setColumndata() [12/12]

int GenericDbTable::setColumndata ( unsigned n_column,
const std::vector< std::vector< std::string > > & data )

Insert a subset in a column of vectors of strings.

Parameters
n_columnRefers to the column number
datarefers to the values to be appended in the column
Returns
the number of values inserted
See also
getNames(); getTypes()

Definition at line 1438 of file GenericDbTable.cxx.

1439{
1440 if (!m_isInitialized)
1441 return CDB_NOT_INITIALIZED;
1442
1443 unsigned index = 0;
1444 if (n_column < m_conddbtable.size())
1445 {
1446 if (m_conddbtable[n_column]->type == kArrayString)
1447 {
1448 CondDBColumnArrayString* tmpColumn = static_cast<CondDBColumnArrayString*>(m_conddbtable[n_column]);
1449 while((tmpColumn->column.size() < m_numRows+1) && (index < data.size()))
1450 {
1451 tmpColumn->column.push_back(data[index]);
1452 index++;
1453 }
1454 return index;
1455 }
1456 else
1457 {
1458// If the data type is not string we can convert the string to the corresponding type
1459 switch(m_conddbtable[n_column]->type)
1460 {
1461//if the column data type is an array of any type each inner vector refers to a vector on a cell
1462 case kArrayInt:
1463 {
1464 vector<vector<long int> > aux;
1465 for (unsigned j=0; j<data.size(); j++)
1466 {
1467 vector<long int> tmp;
1468 for (unsigned i=0; i<data[j].size(); i++)
1469 {
1470 if (data[j][i]=="NULL")
1471 {
1472 long int null;
1473 getNull(n_column, null);
1474 tmp.push_back(null);
1475 }
1476 else
1477 tmp.push_back(atol(data[j][i].c_str()));
1478 }
1479 aux.push_back(std::move(tmp));
1480 }
1481 index = setColumndata(n_column, aux);
1482 break;
1483 }
1484 case kArrayLongLong:
1485 {
1486 vector<vector<int64> > aux;
1487 for (unsigned j=0; j<data.size(); j++)
1488 {
1489 vector<int64> tmp;
1490 for (unsigned i=0; i<data[j].size(); i++)
1491 {
1492 if (data[j][i]=="NULL")
1493 {
1494 int64 null;
1495 getNull(n_column, null);
1496 tmp.push_back(null);
1497 }
1498 else
1499 tmp.push_back(atoi64(data[j][i].c_str()));
1500 }
1501 aux.push_back(std::move(tmp));
1502 }
1503 index = setColumndata(n_column, aux);
1504 break;
1505 }
1506 case kArrayBool:
1507 {
1508 vector<vector<short int> > aux;
1509 for (unsigned j=0; j<data.size(); j++)
1510 {
1511 vector<short int> tmp;
1512 for (unsigned i=0; i<data[j].size(); i++)
1513 {
1514 if (data[j][i]=="NULL")
1515 {
1516 tmp.push_back(-1);
1517 }
1518 else
1519 tmp.push_back(atoi(data[j][i].c_str()));
1520 }
1521 aux.push_back(std::move(tmp));
1522 }
1523 index = setColumndata(n_column, aux);
1524 break;
1525 }
1526 case kArrayFloat:
1527 {
1528 vector<vector<float> > aux;
1529 for (unsigned j=0; j<data.size(); j++)
1530 {
1531 vector<float> tmp;
1532 for (unsigned i=0; i<data[j].size(); i++)
1533 {
1534 if (data[j][i]=="NULL")
1535 {
1536 float null;
1537 getNull(n_column, null);
1538 tmp.push_back(null);
1539 }
1540 else
1541 tmp.push_back(atof(data[j][i].c_str()));
1542 }
1543 aux.push_back(std::move(tmp));
1544 }
1545 index = setColumndata(n_column, aux);
1546 break;
1547 }
1548 case kArrayDouble:
1549 {
1550 vector<vector<double> > aux;
1551 for (unsigned j=0; j<data.size(); j++)
1552 {
1553 vector<double> tmp;
1554 for (unsigned i=0; i<data[j].size(); i++)
1555 {
1556 if (data[j][i]=="NULL")
1557 {
1558 double null;
1559 getNull(n_column, null);
1560 tmp.push_back(null);
1561 }
1562 else
1563 tmp.push_back(strtod(data[j][i].c_str(), (char**)NULL));
1564 }
1565 aux.push_back(std::move(tmp));
1566 }
1567 index = setColumndata(n_column, aux);
1568 break;
1569 }
1570 default:
1571 return CDB_STRTOARRAY_ERROR;
1572 }
1573 return index;
1574 }
1575 }
1576 else
1577 return CDB_RANGE_ERROR;
1578
1579}

◆ setName()

int GenericDbTable::setName ( unsigned n_column,
const std::string & name )

This method defines the name for a specified column.

Parameters
n_columnis the column number
nameis a string with the name
Returns
an error code

Definition at line 337 of file GenericDbTable.cxx.

338{
339 if (m_conddbtable.size() > n_column)
340 if (m_conddbtable[n_column]->name.size() == 0)
341 {
342 m_conddbtable[n_column]->name = name;
343 if (m_conddbtable[n_column]->type != kNull)
344 {
345 m_conddbtable[n_column]->initialized = true;
346 verifyInitialization();
347 }
348 }
349 else
350 return CDB_TYPE_ERROR;
351 else
352 return CDB_RANGE_ERROR;
353 return CDB_SUCCESS;
354}
GenericDbTable::verifyInitialization
void verifyInitialization()
Verifies if all columns are initialized.
Definition GenericDbTable.cxx:1744

◆ setNull() [1/5]

int GenericDbTable::setNull ( unsigned n_column,
const double & null )

Definition at line 656 of file GenericDbTable.cxx.

657{
658 if (!m_isInitialized)
659 return CDB_NOT_INITIALIZED;
660
661 if (m_conddbtable.size() > n_column)
662 if (m_conddbtable[n_column]->type == kDouble || m_conddbtable[n_column]->type == kArrayDouble)
663 {
664 static_cast<CondDBColumnDouble*>(m_conddbtable[n_column])->column[0] = null;
665 return CDB_SUCCESS;
666 }
667 else if (m_conddbtable[n_column]->type == kArrayDouble)
668 {
669 static_cast<CondDBColumnArrayDouble*>(m_conddbtable[n_column])->column[0] = vector<double> (1, null);
670 return CDB_SUCCESS;
671 }
672 else
673 return CDB_TYPE_ERROR;
674 else
675 return CDB_RANGE_ERROR;
676}

◆ setNull() [2/5]

int GenericDbTable::setNull ( unsigned n_column,
const float & null )

Set Null value for column.

Definition at line 634 of file GenericDbTable.cxx.

635{
636 if (!m_isInitialized)
637 return CDB_NOT_INITIALIZED;
638
639 if (m_conddbtable.size() > n_column)
640 if (m_conddbtable[n_column]->type == kFloat )
641 {
642 static_cast<CondDBColumnFloat*>(m_conddbtable[n_column])->column[0] = null;
643 return CDB_SUCCESS;
644 }
645 else if (m_conddbtable[n_column]->type == kArrayFloat)
646 {
647 static_cast<CondDBColumnArrayFloat*>(m_conddbtable[n_column])->column[0] = vector<float> (1,null);
648 return CDB_SUCCESS;
649 }
650 else
651 return CDB_TYPE_ERROR;
652 else
653 return CDB_RANGE_ERROR;
654}

◆ setNull() [3/5]

int GenericDbTable::setNull ( unsigned n_column,
const int64 & null )

Definition at line 612 of file GenericDbTable.cxx.

613{
614 if (!m_isInitialized)
615 return CDB_NOT_INITIALIZED;
616
617 if (m_conddbtable.size() > n_column)
618 if (m_conddbtable[n_column]->type == kLongLong )
619 {
620 static_cast<CondDBColumnLong*>(m_conddbtable[n_column])->column[0] = null;
621 return CDB_SUCCESS;
622 }
623 else if (m_conddbtable[n_column]->type == kArrayLongLong)
624 {
625 static_cast<CondDBColumnArrayLong*>(m_conddbtable[n_column])->column[0] = vector<int64> (1,null);
626 return CDB_SUCCESS;
627 }
628 else
629 return CDB_TYPE_ERROR;
630 else
631 return CDB_RANGE_ERROR;
632}

◆ setNull() [4/5]

int GenericDbTable::setNull ( unsigned n_column,
const long int & null )

Definition at line 590 of file GenericDbTable.cxx.

591{
592 if (!m_isInitialized)
593 return CDB_NOT_INITIALIZED;
594
595 if (m_conddbtable.size() > n_column)
596 if (m_conddbtable[n_column]->type == kInt)
597 {
598 static_cast<CondDBColumnInt*>(m_conddbtable[n_column])->column[0] = null;
599 return CDB_SUCCESS;
600 }
601 else if (m_conddbtable[n_column]->type == kArrayInt)
602 {
603 static_cast<CondDBColumnArrayInt*>(m_conddbtable[n_column])->column[0] = vector<long int> (1,null);
604 return CDB_SUCCESS;
605 }
606 else
607 return CDB_TYPE_ERROR;
608 else
609 return CDB_RANGE_ERROR;
610}

◆ setNull() [5/5]

int GenericDbTable::setNull ( unsigned n_column,
const std::string & null )

Definition at line 520 of file GenericDbTable.cxx.

521{
522 if (!m_isInitialized)
523 return CDB_NOT_INITIALIZED;
524
525 if (m_conddbtable.size() > n_column)
526 switch (m_conddbtable[n_column]->type)
527 {
528 case kString:
529 {
530 static_cast<CondDBColumnString*>(m_conddbtable[n_column])->column[0] = null;
531 return CDB_SUCCESS;
532 }
533 case kArrayString:
534 {
535 static_cast<CondDBColumnArrayString*>(m_conddbtable[n_column])->column[0] = vector<string> (1,null);
536 return CDB_SUCCESS;
537 }
538 case kFloat:
539 {
540 static_cast<CondDBColumnFloat*>(m_conddbtable[n_column])->column[0] = atof(null.c_str());
541 return CDB_SUCCESS;
542 }
543 case kArrayFloat:
544 {
545 static_cast<CondDBColumnArrayFloat*>(m_conddbtable[n_column])->column[0] = vector<float> (1,atof(null.c_str()));
546 return CDB_SUCCESS;
547 }
548 case kInt:
549 {
550 static_cast<CondDBColumnInt*>(m_conddbtable[n_column])->column[0] = atol(null.c_str());
551 return CDB_SUCCESS;
552 }
553 case kArrayInt:
554 {
555 static_cast<CondDBColumnArrayInt*>(m_conddbtable[n_column])->column[0] = vector<long int> (1,atol(null.c_str()));
556 return CDB_SUCCESS;
557 }
558 case kBool:
559 case kArrayBool:
560 {
561 return CDB_SUCCESS;
562 }
563 case kLongLong:
564 {
565 static_cast<CondDBColumnString*>(m_conddbtable[n_column])->column[0] = atoi64(null.c_str());
566 return CDB_SUCCESS;
567 }
568 case kArrayLongLong:
569 {
570 static_cast<CondDBColumnArrayLong*>(m_conddbtable[n_column])->column[0] = vector<int64> (1,atoi64(null.c_str()));
571 return CDB_SUCCESS;
572 }
573 case kDouble:
574 {
575 static_cast<CondDBColumnDouble*>(m_conddbtable[n_column])->column[0] = atof(null.c_str());
576 return CDB_SUCCESS;
577 }
578 case kArrayDouble:
579 {
580 static_cast<CondDBColumnArrayDouble*>(m_conddbtable[n_column])->column[0] = vector<double> (1,atof(null.c_str()));
581 return CDB_SUCCESS;
582 }
583 default:
584 return CDB_TYPE_ERROR;
585 }
586 else
587 return CDB_RANGE_ERROR;
588}

◆ setType()

int GenericDbTable::setType ( unsigned n_column,
dataTypes type )

This method defines the data type for a specified column.

Parameters
n_columnis the column number
typeis a the type
Returns
an error code

Definition at line 356 of file GenericDbTable.cxx.

357{
358 if (m_conddbtable.size() > n_column)
359 if (m_conddbtable[n_column]->type == kNull)
360 {
361 m_conddbtable[n_column]->type = type;
362
363 switch (type)
364 {
365 case kBool:
366 {
367 CondDBColumnBool * tmpColumn = new CondDBColumnBool;
368 tmpColumn->type = m_conddbtable[n_column]->type;
369 tmpColumn->column.push_back(-1);
370 if ((m_conddbtable[n_column]->name.size()))
371 tmpColumn->name = m_conddbtable[n_column]->name;
372
373 delete(m_conddbtable[n_column]);
374 m_conddbtable[n_column] = tmpColumn;
375 break;
376 }
377 case kInt:
378 {
379 CondDBColumnInt * tmpColumn = new CondDBColumnInt;
380 tmpColumn->type = m_conddbtable[n_column]->type;
381 tmpColumn->column.push_back(NULLINT);
382 if ((m_conddbtable[n_column]->name.size()))
383 tmpColumn->name = m_conddbtable[n_column]->name;
384 delete(m_conddbtable[n_column]);
385 m_conddbtable[n_column] = tmpColumn;
386 break;
387 }
388 case kLongLong:
389 {
390 CondDBColumnLong * tmpColumn = new CondDBColumnLong;
391 tmpColumn->type = m_conddbtable[n_column]->type;
392 tmpColumn->column.push_back(NULLLONG);
393 if ((m_conddbtable[n_column]->name.size()))
394 tmpColumn->name = m_conddbtable[n_column]->name;
395 delete(m_conddbtable[n_column]);
396 m_conddbtable[n_column] = tmpColumn;
397 break;
398 }
399
400 case kFloat:
401 {
402 CondDBColumnFloat * tmpColumn = new CondDBColumnFloat;
403 tmpColumn->type = m_conddbtable[n_column]->type;
404 tmpColumn->column.push_back(NULLFLOAT);
405 if ((m_conddbtable[n_column]->name.size()))
406 tmpColumn->name = m_conddbtable[n_column]->name;
407 delete(m_conddbtable[n_column]);
408 m_conddbtable[n_column] = tmpColumn;
409 break;
410 }
411 case kString:
412 {
413 CondDBColumnString * tmpColumn = new CondDBColumnString;
414 tmpColumn->type = m_conddbtable[n_column]->type;
415 tmpColumn->column.push_back("NULL");
416 if ((m_conddbtable[n_column]->name.size()))
417 tmpColumn->name = m_conddbtable[n_column]->name;
418
419 delete(m_conddbtable[n_column]);
420 m_conddbtable[n_column] = tmpColumn;
421 break;
422 }
423 case kDouble:
424 {
425 CondDBColumnDouble * tmpColumn = new CondDBColumnDouble;
426 tmpColumn->type = m_conddbtable[n_column]->type;
427 tmpColumn->column.push_back(NULLDOUBLE);
428 if ((m_conddbtable[n_column]->name.size()))
429 tmpColumn->name = m_conddbtable[n_column]->name;
430
431 delete(m_conddbtable[n_column]);
432 m_conddbtable[n_column] = tmpColumn;
433 break;
434 }
435 case kArrayInt:
436 {
437 CondDBColumnArrayInt * tmpColumn = new CondDBColumnArrayInt;
438 tmpColumn->type = m_conddbtable[n_column]->type;
439 tmpColumn->column.push_back({NULLINT});
440 if ((m_conddbtable[n_column]->name.size()))
441 tmpColumn->name = m_conddbtable[n_column]->name;
442 delete(m_conddbtable[n_column]);
443 m_conddbtable[n_column] = tmpColumn;
444 break;
445 }
446 case kArrayLongLong:
447 {
448 CondDBColumnArrayLong * tmpColumn = new CondDBColumnArrayLong;
449 tmpColumn->type = m_conddbtable[n_column]->type;
450 tmpColumn->column.push_back({NULLLONG});
451 if ((m_conddbtable[n_column]->name.size()))
452 tmpColumn->name = m_conddbtable[n_column]->name;
453 delete(m_conddbtable[n_column]);
454 m_conddbtable[n_column] = tmpColumn;
455 break;
456 }
457 case kArrayBool:
458 {
459 CondDBColumnArrayBool * tmpColumn = new CondDBColumnArrayBool;
460 tmpColumn->type = m_conddbtable[n_column]->type;
461 tmpColumn->column.push_back({-1});
462 if ((m_conddbtable[n_column]->name.size()))
463 tmpColumn->name = m_conddbtable[n_column]->name;
464 delete(m_conddbtable[n_column]);
465 m_conddbtable[n_column] = tmpColumn;
466 break;
467 }
468 case kArrayFloat:
469 {
470 CondDBColumnArrayFloat * tmpColumn = new CondDBColumnArrayFloat;
471 tmpColumn->type = m_conddbtable[n_column]->type;
472 tmpColumn->column.push_back({NULLFLOAT});
473 if ((m_conddbtable[n_column]->name.size()))
474 tmpColumn->name = m_conddbtable[n_column]->name;
475 delete(m_conddbtable[n_column]);
476 m_conddbtable[n_column] = tmpColumn;
477 break;
478 }
479 case kArrayString:
480 {
481 CondDBColumnArrayString * tmpColumn = new CondDBColumnArrayString;
482 tmpColumn->type = m_conddbtable[n_column]->type;
483 vector<string> tmp;
484 tmp.push_back("NULL");
485 tmpColumn->column.push_back({"NULL"});
486 if ((m_conddbtable[n_column]->name.size()))
487 tmpColumn->name = m_conddbtable[n_column]->name;
488 delete(m_conddbtable[n_column]);
489 m_conddbtable[n_column] = tmpColumn;
490 break;
491 }
492 case kArrayDouble:
493 {
494 CondDBColumnArrayDouble * tmpColumn = new CondDBColumnArrayDouble;
495 tmpColumn->type = m_conddbtable[n_column]->type;
496 tmpColumn->column.push_back({NULLDOUBLE});
497 if ((m_conddbtable[n_column]->name.size()))
498 tmpColumn->name = m_conddbtable[n_column]->name;
499 delete(m_conddbtable[n_column]);
500 m_conddbtable[n_column] = tmpColumn;
501 break;
502 }
503 default : break;
504 }
505
506 if (m_conddbtable[n_column]->name.size() != 0)
507 {
508 m_conddbtable[n_column]->initialized = true;
509 verifyInitialization();
510 }
511 }
512 else
513 return CDB_TYPE_ERROR;
514 else
515 return CDB_RANGE_ERROR;
516 return CDB_SUCCESS;
517
518}
NULLFLOAT
#define NULLFLOAT
Definition GenericDbTable.cxx:12
NULLLONG
#define NULLLONG
Definition GenericDbTable.cxx:18
NULLDOUBLE
#define NULLDOUBLE
Definition GenericDbTable.cxx:13
NULLINT
#define NULLINT
Definition GenericDbTable.cxx:11

◆ ToString()

template<class TYPE>
std::string GenericDbTable::ToString ( const TYPE & t) const
inlineprivate

Auxiliary function to convert any value to string.

Parameters
tis the value to be converted
Returns
a string with the value passed.

Definition at line 651 of file GenericDbTable.h.

651 {
652 //CONDDBTABLESTREAM os;
653 std::ostringstream os;
654 os << t;
655 return os.str();
656}
read_hist_ntuple.t
t
Definition read_hist_ntuple.py:5

◆ verifyInitialization()

void GenericDbTable::verifyInitialization ( )
private

Verifies if all columns are initialized.

Definition at line 1744 of file GenericDbTable.cxx.

1745{
1746 bool aux = true;
1747
1748 for (unsigned i=0; i< m_conddbtable.size(); i++)
1749 {
1750 if (!(m_conddbtable[i]->initialized))
1751 {
1752 aux = false;
1753 break;
1754 }
1755 }
1756
1757 if (aux)
1758 m_isInitialized = true;
1759}

Member Data Documentation

◆ m_conddbtable

std::vector<CondDBColumn*> GenericDbTable::m_conddbtable
private

Definition at line 734 of file GenericDbTable.h.

◆ m_isInitialized

bool GenericDbTable::m_isInitialized
private

Definition at line 733 of file GenericDbTable.h.

◆ m_numRows

unsigned GenericDbTable::m_numRows
private

Definition at line 735 of file GenericDbTable.h.

The documentation for this class was generated from the following files:
Generated on for ATLAS Offline Software by doxygen 1.14.0