lsst::daf::persistence::DbStorageImpl Class Reference

Class for implementation of database storage. More...

#include <DbStorageImpl.h>

Inheritance diagram for lsst::daf::persistence::DbStorageImpl:

Public Types
enum	{ magicSentinel = 0xdeadbeef }
typedef unsigned long	memId
	Type of the block's ID. More...
typedef memId(*	memNewCallback) (const memId cid)
	A function used to register a callback. More...
typedef memId(*	memCallback) (const Citizen *ptr)

Public Member Functions
virtual	~DbStorageImpl (void)
	Destructor. More...
template<>
void	setColumn (std::string const &columnName, std::string const &value)
template<>
void	setColumn (std::string const &columnName, dafBase::DateTime const &value)
template<>
void	outParam (std::string const &columnName, std::string *location, bool isExpr)
template<>
void	outParam (std::string const &columnName, dafBase::DateTime *location, bool isExpr)
template<>
std::string const &	getColumnByPos (int pos)
template<>
dafBase::DateTime const &	getColumnByPos (int pos)
std::string	repr () const
	Return a string representation of a Citizen. More...
void	markPersistent (void)
	Mark a Citizen as persistent and not destroyed until process end. More...
memId	getId () const
	Return the Citizen's ID. More...

Static Public Member Functions
static bool	hasBeenCorrupted ()
	Check all allocated blocks for corruption. More...
static memId	getNextMemId ()
	Return the memId of the next object to be allocated. More...
static int	init ()
	Called once when the memory system is being initialised. More...
Census
Provide a list of current Citizens
static int	census (int, memId startingMemId=0)
	How many active Citizens are there? More...
static void	census (std::ostream &stream, memId startingMemId=0)
	Print a list of all active Citizens to stream, sorted by ID. More...
static const std::vector< const Citizen * > *	census ()
	Return a (newly allocated) std::vector of active Citizens sorted by ID. More...
callbackIDs
Set callback Ids. The old Id is returned
static memId	setNewCallbackId (memId id)
	Call the NewCallback when block is allocated. More...
static memId	setDeleteCallbackId (memId id)
	Call the current DeleteCallback when block is deleted. More...
callbacks
Set the New/Delete callback functions; in each case the previously installed callback is returned. These callback functions return a value which is Added to the previously registered id. The default callback functions are called default{New,Delete}Callback; you may want to set a break point in these callbacks from your favourite debugger
static memNewCallback	setNewCallback (memNewCallback func)
	Set the NewCallback function. More...
static memCallback	setDeleteCallback (memCallback func)
	Set the DeleteCallback function. More...
static memCallback	setCorruptionCallback (memCallback func)
	Set the CorruptionCallback function. More...

Private Types
typedef std::unordered_map< std::string, BoundVar >	BoundVarMap

Private Member Functions
	DbStorageImpl (void)
	Default constructor. More...
virtual void	setPolicy (pexPolicy::Policy::Ptr policy)
	Allow a Policy to be used to configure the DbStorage. More...
virtual void	setPersistLocation (LogicalLocation const &location)
	Set the database location to persist to. More...
virtual void	setRetrieveLocation (LogicalLocation const &location)
	Set the database location to retrieve from. More...
virtual void	startTransaction (void)
	Start a transaction. More...
virtual void	endTransaction (void)
	End a transaction. More...
virtual void	startSession (std::string const &location)
	Start a database session. More...
virtual void	createTableFromTemplate (std::string const &tableName, std::string const &templateName, bool mayAlreadyExist)
	Create a new table from an existing template table. More...
virtual void	dropTable (std::string const &tableName)
	Drop a table. More...
virtual void	truncateTable (std::string const &tableName)
	Truncate a table. More...
virtual void	executeSql (std::string const &sqlStatement)
	Execute an arbitrary SQL statement. More...
virtual void	setTableForInsert (std::string const &tableName)
	Set the table to insert rows into. More...
template<typename T >
void	setColumn (std::string const &columnName, T const &value)
	Set the value to insert in a given column. More...
virtual void	setColumnToNull (std::string const &columnName)
	Set a given column to NULL. More...
virtual void	insertRow (void)
	Insert the row. More...
virtual void	setTableForQuery (std::string const &tableName, bool isExpr)
	Set the table to query (single-table queries only). More...
virtual void	setTableListForQuery (std::vector< std::string > const &tableNameList)
	Set a list of tables to query (multiple-table queries). More...
virtual void	outColumn (std::string const &columnName, bool isExpr)
	Request a column in the query output. More...
template<typename T >
void	outParam (std::string const &columnName, T *location, bool isExpr)
	Request a column in the query output and bind a destination location. More...
template<typename T >
void	condParam (std::string const &paramName, T const &value)
	Bind a value to a WHERE condition parameter. More...
virtual void	orderBy (std::string const &expression)
	Request that the query output be sorted by an expression. More...
virtual void	groupBy (std::string const &expression)
	Request that the query output be grouped by an expression. More...
virtual void	setQueryWhere (std::string const &whereClause)
	Set the condition for the WHERE clause of the query. More...
virtual void	query (void)
	Execute the query. More...
virtual bool	next (void)
	Move to the next (first) row of the query result. More...
template<typename T >
T const &	getColumnByPos (int pos)
	Get the value of a column of the query result row by position. More...
bool	columnIsNull (int pos)
	Determine if the value of a column is NULL. More...
virtual void	finishQuery (void)
	Indicate that query processing is finished. More...
void	executeQuery (std::string const &query)
	Execute a query string. More...
std::string	quote (std::string const &name)
	Quote a name in ANSI-standard fashion. More...
void	stError (std::string const &text)
void	error (std::string const &text, bool mysqlCaused=true)
void *	allocateMemory (size_t size)

Private Attributes
bool	_readonly
	Remember if we are supposed to be read-only. More...
std::string	_location
	Database location string saved for use by raw MySQL interface. More...
MYSQL *	_db
	MySQL database connection pointer. More...
std::string	_insertTable
	Name of table into which to insert. More...
std::vector< std::string >	_queryTables
	Names of tables to select from. More...
BoundVarMap	_inputVars
	Input variable bindings. More...
BoundVarMap	_outputVars
	Output variable bindings. More...
std::vector< boost::shared_array< char > >	_bindingMemory
	Memory for bound variables. More...
std::vector< std::string >	_outColumns
std::string	_whereClause
std::string	_groupBy
std::string	_orderBy
MYSQL_STMT *	_statement
	Prepared query statement. More...
MYSQL_FIELD *	_resultFields
	Query result field metadata. More...
int	_numResultFields
	Number of result fields. More...
boost::shared_array< unsigned long >	_fieldLengths
	Space for lengths of result fields. More...
boost::shared_array< my_bool >	_fieldNulls
	Space for null flags of result fields. More...

Friends
class	DbStorage

Detailed Description

Class for implementation of database storage.

Use via DbStorage class only.

Definition at line 79 of file DbStorageImpl.h.

Member Typedef Documentation

BoundVarMap

typedef std::unordered_map<std::string, BoundVar> lsst::daf::persistence::DbStorageImpl::BoundVarMap

private

Definition at line 150 of file DbStorageImpl.h.

memCallback

typedef memId(* lsst::daf::base::Citizen::memCallback) (const Citizen *ptr)

inherited

Definition at line 59 of file Citizen.h.

memId

typedef unsigned long lsst::daf::base::Citizen::memId

inherited

Type of the block's ID.

Definition at line 56 of file Citizen.h.

memNewCallback

typedef memId(* lsst::daf::base::Citizen::memNewCallback) (const memId cid)

inherited

A function used to register a callback.

Definition at line 58 of file Citizen.h.

Member Enumeration Documentation

anonymous enum

anonymous enum

inherited

Enumerator
magicSentinel

Definition at line 86 of file Citizen.h.

{ magicSentinel = 0xdeadbeef }; 

Constructor & Destructor Documentation

~DbStorageImpl()

lsst::daf::persistence::DbStorageImpl::~DbStorageImpl ( void  )

virtual

Destructor.

End session if present.

Definition at line 175 of file DbStorageImpl.cc.

                                        {
    if (_db) {
        mysql_close(_db);
        _db = 0;
    }
}

DbStorageImpl()

lsst::daf::persistence::DbStorageImpl::DbStorageImpl ( void  )

private

Default constructor.

Definition at line 168 of file DbStorageImpl.cc.

                                       :
    lsst::daf::base::Citizen(typeid(*this)), _db(0) {
}

Member Function Documentation

allocateMemory()

void * lsst::daf::persistence::DbStorageImpl::allocateMemory ( size_t  size )

private

Definition at line 289 of file DbStorageImpl.cc.

                                                     {
    boost::shared_array<char> mem(new char[size]);
    _bindingMemory.push_back(mem);
    return mem.get();
}

census() [1/3]

int lsst::daf::base::Citizen::census ( int  , memId  startingMemId = 0  )

staticinherited

How many active Citizens are there?

Parameters

startingMemId

Don't print Citizens with lower IDs

Definition at line 267 of file Citizen.cc.

      {
    if (startingMemId == 0) {              // easy
        ReadGuard guard(citizenLock);
        return _activeCitizens.size();
    }

    int n = 0;
    ReadGuard guard(citizenLock);
    for (table::iterator cur = _activeCitizens.begin();
         cur != _activeCitizens.end(); cur++) {
        if (cur->first->_CitizenId >= startingMemId) {
            n++;
        }
    }

    return n;    
}

census() [2/3]

void lsst::daf::base::Citizen::census ( std::ostream &  stream, memId  startingMemId = 0  )

staticinherited

Print a list of all active Citizens to stream, sorted by ID.

Parameters

stream	stream to print to
startingMemId	Don't print Citizens with lower IDs

Definition at line 290 of file Citizen.cc.

      {
    ReadGuard guard(citizenLock);

    std::unique_ptr<std::vector<Citizen const*> const> leaks(Citizen::census());

    for (std::vector<Citizen const *>::const_iterator citizen = leaks->begin(), end = leaks->end();
         citizen != end; ++citizen) {
        if ((*citizen)->getId() >= startingMemId) {
            stream << (*citizen)->repr() << "\n";
        }
    }
}

census() [3/3]

std::vector< dafBase::Citizen const * > const * lsst::daf::base::Citizen::census ( )

staticinherited

Return a (newly allocated) std::vector of active Citizens sorted by ID.

You are responsible for deleting it; or you can say std::unique_ptr<std::vector<Citizen const*> const> leaks(Citizen::census()); and not bother (that becomes std::unique_ptr in C++11)

Definition at line 322 of file Citizen.cc.

                                                               {
    std::vector<Citizen const*>* vec =
        new std::vector<Citizen const*>(0);
    ReadGuard guard(citizenLock);
    vec->reserve(_activeCitizens.size());

    for (table::iterator cur = _activeCitizens.begin();
         cur != _activeCitizens.end(); cur++) {
        vec->push_back(dynamic_cast<Citizen const*>(cur->first));
    }
        
    std::sort(vec->begin(), vec->end(), cmpId);

    return vec;
}

columnIsNull()

bool lsst::daf::persistence::DbStorageImpl::columnIsNull ( int  pos )

private

Determine if the value of a column is NULL.

Parameters

[in]

pos

Position of the column (starts at 0)

Returns

true if value is NULL

Definition at line 985 of file DbStorageImpl.cc.

                                              {
    if (pos > _numResultFields) {
        std::ostringstream os;
        os << "Nonexistent column: " << pos;
        error(os.str(), false);
    }
    return _fieldNulls[pos];
}

condParam()

template<typename T >

void lsst::daf::persistence::DbStorageImpl::condParam ( std::string const &  paramName, T const &  value  )

private

Bind a value to a WHERE condition parameter.

Parameters

[in]	paramName	Name of the parameter (prefixed by ":" in the WHERE clause)
[in]	value	Value to be bound to the parameter.

Definition at line 633 of file DbStorageImpl.cc.

                                                                              {
    setColumn<T>(paramName, value);
}

createTableFromTemplate()

void lsst::daf::persistence::DbStorageImpl::createTableFromTemplate ( std::string const &  tableName, std::string const &  templateName, bool  mayAlreadyExist  )

privatevirtual

Create a new table from an existing template table.

Parameters

[in]	tableName	Name of the new table
[in]	templateName	Name of the existing template table
[in]	mayAlreadyExist	False (default) if the table must not be present

Definition at line 304 of file DbStorageImpl.cc.

                                                              {
    std::string query = "CREATE TABLE ";
    if (mayAlreadyExist) query += "IF NOT EXISTS ";
    query += quote(tableName) + " LIKE " + quote(templateName);
    executeQuery(query);
}

dropTable()

void lsst::daf::persistence::DbStorageImpl::dropTable ( std::string const &  tableName )

privatevirtual

Drop a table.

Parameters

[in]

tableName

Name of the table to drop

Definition at line 316 of file DbStorageImpl.cc.

                                                              {
    executeQuery("DROP TABLE " + quote(tableName));
}

endTransaction()

void lsst::daf::persistence::DbStorageImpl::endTransaction ( void  )

privatevirtual

End a transaction.

Definition at line 244 of file DbStorageImpl.cc.

                                             {
    if (_db == 0) error("Database session not initialized "
                        "in DbStorage::endTransaction()", false);
    if (mysql_commit(_db)) error("Unable to commit transaction");
    if (mysql_autocommit(_db, true)) error("Unable to turn on autocommit");
}

error()

void lsst::daf::persistence::DbStorageImpl::error ( std::string const &  text, bool  mysqlCaused = true  )

private

Definition at line 280 of file DbStorageImpl.cc.

                                                                      {
    if (mysqlCause) {
        throw LSST_EXCEPT(lsst::pex::exceptions::RuntimeError, text + " - * " + mysql_error(_db));
    }
    else {
        throw LSST_EXCEPT(lsst::pex::exceptions::RuntimeError, text);
    }
}

executeQuery()

void lsst::daf::persistence::DbStorageImpl::executeQuery ( std::string const &  query )

private

Execute a query string.

Definition at line 257 of file DbStorageImpl.cc.

                                                             {
    if (_db == 0) {
        error("No DB connection for query: " + query, false);
    }
    LOGLS_DEBUG(_log, "Query: " << query);
    if (mysql_query(_db, query.c_str()) != 0) {
        error("Unable to execute query: " + query);
    }
}

executeSql()

void lsst::daf::persistence::DbStorageImpl::executeSql ( std::string const &  sqlStatement )

privatevirtual

Execute an arbitrary SQL statement.

Use primarily to perform server-side computations or complex DDL.

Parameters

[in]

sqlStatement

SQL statement to be executed. Must not end in ";".

Definition at line 331 of file DbStorageImpl.cc.

                                                                  {
    executeQuery(sqlStatement);
}

finishQuery()

void lsst::daf::persistence::DbStorageImpl::finishQuery ( void  )

privatevirtual

Indicate that query processing is finished.

Definition at line 996 of file DbStorageImpl.cc.

                                          {
    mysql_stmt_close(_statement);
    _statement = 0;
}

getColumnByPos() [1/3]

template<typename T >

T const & lsst::daf::persistence::DbStorageImpl::getColumnByPos ( int  pos )

private

Get the value of a column of the query result row by position.

Parameters

[in]

pos

Position of the column (starts at 0)

Returns

Reference to the value of the column

Definition at line 896 of file DbStorageImpl.cc.

                                                    {
    if (pos > _numResultFields) {
        std::ostringstream os;
        os << "Nonexistent column: " << pos;
        error(os.str(), false);
    }
    MYSQL_BIND bind;
    memset(&bind, 0, sizeof(MYSQL_BIND));
    static T t;
    bind.buffer_type = BoundVarTraits<T>::mysqlType;
    bind.is_unsigned = BoundVarTraits<T>::isUnsigned;
    bind.buffer = &t;
    bind.buffer_length = sizeof(T);
    bind.length = &(_fieldLengths[pos]);
    bind.is_null = &(_fieldNulls[pos]);
    if (mysql_stmt_fetch_column(_statement, &bind, pos, 0)) {
        std::ostringstream os;
        os << "Error fetching column: " << pos;
        error(os.str(), false);
    }
    return t;
}

getColumnByPos() [2/3]

template<>

std::string const& lsst::daf::persistence::DbStorageImpl::getColumnByPos

(

int

pos

)

Definition at line 920 of file DbStorageImpl.cc.

                                                            {
    if (pos > _numResultFields) {
        std::ostringstream os;
        os << "Nonexistent column: " << pos;
        error(os.str(), false);
    }
    MYSQL_BIND bind;
    memset(&bind, 0, sizeof(MYSQL_BIND));
    if (_resultFields[pos].type == MYSQL_TYPE_BIT) {
        error("Invalid type for string retrieval", false);
    }
    std::unique_ptr<char[]> t(new char[_fieldLengths[pos]]);
    bind.buffer_type = BoundVarTraits<std::string>::mysqlType;
    bind.is_unsigned = BoundVarTraits<std::string>::isUnsigned;
    bind.buffer = t.get();
    bind.buffer_length = _fieldLengths[pos];
    bind.length = &(_fieldLengths[pos]);
    bind.is_null = &(_fieldNulls[pos]);
    if (mysql_stmt_fetch_column(_statement, &bind, pos, 0)) {
        std::ostringstream os;
        os << "Error fetching string column: " << pos;
        stError(os.str());
    }
    static std::string s;
    s = std::string(t.get(), _fieldLengths[pos]);
    return s;
}

getColumnByPos() [3/3]

template<>

dafBase::DateTime const& lsst::daf::persistence::DbStorageImpl::getColumnByPos

(

int

pos

)

Definition at line 949 of file DbStorageImpl.cc.

                                                                  {
    if (pos > _numResultFields) {
        std::ostringstream os;
        os << "Nonexistent column: " << pos;
        error(os.str(), false);
    }
    MYSQL_BIND bind;
    memset(&bind, 0, sizeof(MYSQL_BIND));
    if (_resultFields[pos].type != MYSQL_TYPE_TIME &&
        _resultFields[pos].type != MYSQL_TYPE_DATE &&
        _resultFields[pos].type != MYSQL_TYPE_DATETIME &&
        _resultFields[pos].type != MYSQL_TYPE_TIMESTAMP) {
        error("Invalid type for DateTime retrieval", false);
    }
    static MYSQL_TIME t;
    bind.buffer_type = BoundVarTraits<dafBase::DateTime>::mysqlType;
    bind.is_unsigned = BoundVarTraits<dafBase::DateTime>::isUnsigned;
    bind.buffer = &t;
    bind.buffer_length = sizeof(MYSQL_TIME);
    bind.length = &(_fieldLengths[pos]);
    bind.is_null = &(_fieldNulls[pos]);
    if (mysql_stmt_fetch_column(_statement, &bind, pos, 0)) {
        std::ostringstream os;
        os << "Error fetching DateTime column: " << pos;
        stError(os.str());
    }
    static dafBase::DateTime v;
    v = dafBase::DateTime(t.year, t.month, t.day, t.hour, t.minute, t.second,
                          dafBase::DateTime::UTC);
    return v;
}

getId()

dafBase::Citizen::memId lsst::daf::base::Citizen::getId ( ) const

inherited

Return the Citizen's ID.

Definition at line 224 of file Citizen.cc.

                                                {
    return _CitizenId;
}

getNextMemId()

dafBase::Citizen::memId lsst::daf::base::Citizen::getNextMemId ( )

staticinherited

Return the memId of the next object to be allocated.

Definition at line 229 of file Citizen.cc.

                                                 {
    return _nextMemId();
}

groupBy()

void lsst::daf::persistence::DbStorageImpl::groupBy ( std::string const &  expression )

privatevirtual

Request that the query output be grouped by an expression.

Parameters

[in]

expression

Text of the SQL expression

Definition at line 651 of file DbStorageImpl.cc.

                                                             {
    if (!_groupBy.empty()) {
        _groupBy += ", ";
    }
    _groupBy += expression;
}

hasBeenCorrupted()

bool lsst::daf::base::Citizen::hasBeenCorrupted ( )

staticinherited

Check all allocated blocks for corruption.

Definition at line 353 of file Citizen.cc.

                                      {
    ReadGuard guard(citizenLock);
    for (table::iterator cur = _activeCitizens.begin();
         cur != _activeCitizens.end(); cur++) {
        if (cur->first->_hasBeenCorrupted()) {
            return true;
        }
    }
    for (table::iterator cur = _persistentCitizens.begin();
         cur != _persistentCitizens.end(); cur++) {
        if (cur->first->_hasBeenCorrupted()) {
            return true;
        }
    }

    return false;
}

init()

int lsst::daf::base::Citizen::init ( )

staticinherited

Called once when the memory system is being initialised.

Definition at line 214 of file Citizen.cc.

                         {
    volatile int dummy = 1;
    return dummy;
}

insertRow()

void lsst::daf::persistence::DbStorageImpl::insertRow ( void  )

privatevirtual

Insert the row.

Row values must have been set with setColumn() calls.

Definition at line 441 of file DbStorageImpl.cc.

                                        {
    if (_readonly) {
        error("Attempt to insert into read-only database", false);
    }
    if (_insertTable.empty()) error("Insert table not initialized in DbStorage::insertRow()", false);
    if (_inputVars.empty()) error("No values to insert", false);

    std::string query = "INSERT INTO " + quote(_insertTable) + " (";

    std::unique_ptr<MYSQL_BIND[]> binder(new MYSQL_BIND[_inputVars.size()]);
    memset(binder.get(), 0, _inputVars.size() * sizeof(MYSQL_BIND));

    int i = 0;
    for (BoundVarMap::iterator it = _inputVars.begin();
         it != _inputVars.end(); ++it) {
        if (it != _inputVars.begin()) {
            query += ", ";
        }
        query += quote(it->first);

        // Bind variables
        MYSQL_BIND& bind(binder[i]);
        BoundVar& bv(it->second);
        if (bv._isNull) {
            bind.buffer_type = MYSQL_TYPE_NULL;
        }
        else {
            bind.buffer_type = bv._type;
            bind.buffer = bv._data;
            bind.buffer_length = bv._length;
            bind.length = &(bv._length);
            bind.is_null = 0;
            bind.is_unsigned = bv._isUnsigned;
            bind.error = 0;
        }
        ++i;
    }
    query += ") VALUES (";
    for (size_t i = 0; i < _inputVars.size(); ++i) {
        if (i != 0) {
            query += ", ";
        }
        query += "?";
    }
    query += ")";

    // Execute statement
    // Guard statement with mysql_stmt_close()
    _statement = mysql_stmt_init(_db);
    if (_statement == 0) {
        error("Unable to initialize statement: " + query);
    }
    if (mysql_stmt_prepare(_statement, query.c_str(), query.length()) != 0) {
        stError("Unable to prepare statement: " + query);
    }
    if (mysql_stmt_bind_param(_statement, binder.get())) {
        stError("Unable to bind variables in: " + query);
    }
    if (mysql_stmt_execute(_statement) != 0) {
        stError("Unable to execute statement: " + query);
    }
    mysql_stmt_close(_statement);
    _statement = 0;
}

markPersistent()

void lsst::daf::base::Citizen::markPersistent ( void  )

inherited

Mark a Citizen as persistent and not destroyed until process end.

Definition at line 254 of file Citizen.cc.

                                        {
    WriteGuard guard(citizenLock);
    _persistentCitizens[this] = _activeCitizens[this];
    _activeCitizens.erase(this);
}

next()

bool lsst::daf::persistence::DbStorageImpl::next ( void  )

privatevirtual

Move to the next (first) row of the query result.

Returns

false if no more rows

Definition at line 851 of file DbStorageImpl.cc.

                                   {
    if (_statement == 0) {
        error("Statement not initialized in DbStorage::next()", false);
    }
    int ret = mysql_stmt_fetch(_statement);
    if (ret == 0) {
        // Fix up strings and DateTimes
        if (!_outputVars.empty()) {
            for (size_t i = 0; i < _outColumns.size(); ++i) {
                BoundVarMap::iterator bvit = _outputVars.find(_outColumns[i]);
                if (bvit == _outputVars.end()) {
                    error("Unbound variable in SELECT clause: " +
                          _outColumns[i], false);
                }
                BoundVar& bv = bvit->second;
                if (bv._type == BoundVarTraits<std::string>::mysqlType) {
                    **reinterpret_cast<std::string**>(bv._data) =
                        std::string(reinterpret_cast<char*>(bv._data) +
                                    sizeof(std::string*), _fieldLengths[i]);
                }
                else if (bv._type ==
                         BoundVarTraits<dafBase::DateTime>::mysqlType) {
                    char* cp = reinterpret_cast<char*>(bv._data) +
                        sizeof(dafBase::DateTime*);
                    MYSQL_TIME* t = reinterpret_cast<MYSQL_TIME*>(cp);
                    **reinterpret_cast<dafBase::DateTime**>(bv._data) =
                        dafBase::DateTime(t->year, t->month, t->day,
                                          t->hour, t->minute, t->second,
                                          dafBase::DateTime::UTC);
                }
            }
        }
        return true;
    }
    if (ret == MYSQL_NO_DATA) return false;
    if (ret == MYSQL_DATA_TRUNCATED && _outputVars.empty()) return true;
    stError("Error fetching next row");
    return false;
}

orderBy()

void lsst::daf::persistence::DbStorageImpl::orderBy ( std::string const &  expression )

privatevirtual

Request that the query output be sorted by an expression.

Multiple expressions may be specified, in order.

Parameters

[in]

expression

Text of the SQL expression

Definition at line 641 of file DbStorageImpl.cc.

                                                             {
    if (!_orderBy.empty()) {
        _orderBy += ", ";
    }
    _orderBy += expression;
}

outColumn()

void lsst::daf::persistence::DbStorageImpl::outColumn ( std::string const &  columnName, bool  isExpr  )

privatevirtual

Request a column in the query output.

Parameters

[in]	columnName	Name of the column
[in]	isExpr	True if the name is actually an expression

The order of outColumn() calls is the order of appearance in the output row. Use either outColumn() or outParam() but not both.

Definition at line 554 of file DbStorageImpl.cc.

                                                   {
    std::string col = isExpr ? columnName : quote(columnName);
    _outColumns.push_back(col);
}

outParam() [1/3]

template<typename T >

void lsst::daf::persistence::DbStorageImpl::outParam ( std::string const &  columnName, T *  location, bool  isExpr  )

private

Request a column in the query output and bind a destination location.

Parameters

[in]	columnName	Name of the column
[in]	location	Pointer to the destination
[in]	isExpr	True if the name is actually an expression

The order of outParam() calls is the order of appearance in the output row. Use either outColumn() or outParam() but not both.

Definition at line 569 of file DbStorageImpl.cc.

                                                               {
    std::string col = isExpr ? columnName : quote(columnName);
    _outColumns.push_back(col);
    size_t size = sizeof(T);
    std::pair<BoundVarMap::iterator, bool> pair = _outputVars.insert(
        BoundVarMap::value_type(col, BoundVar(location)));
    if (!pair.second) {
        error("Duplicate column name requested: " + columnName, false);
    }
    BoundVar& bv = pair.first->second;
    bv._type = BoundVarTraits<T>::mysqlType;
    bv._isNull = false;
    bv._isUnsigned = BoundVarTraits<T>::isUnsigned;
    bv._length = size;
}

outParam() [2/3]

template<>

void lsst::daf::persistence::DbStorageImpl::outParam	(	std::string const &	columnName,
		std::string *	location,
		bool	isExpr
	)

Definition at line 587 of file DbStorageImpl.cc.

                                                                       {
    std::string col = isExpr ? columnName : quote(columnName);
    _outColumns.push_back(col);
    size_t size = 4096;
    std::pair<BoundVarMap::iterator, bool> pair = _outputVars.insert(
        BoundVarMap::value_type(
            col, BoundVar(allocateMemory(size + sizeof(std::string*)))));
    if (!pair.second) {
        error("Duplicate column name requested: " + columnName, false);
    }
    BoundVar& bv = pair.first->second;
    *reinterpret_cast<std::string**>(bv._data) = location;
    bv._type = BoundVarTraits<std::string>::mysqlType;
    bv._isNull = false;
    bv._isUnsigned = BoundVarTraits<std::string>::isUnsigned;
    bv._length = size;
}

outParam() [3/3]

template<>

void lsst::daf::persistence::DbStorageImpl::outParam	(	std::string const &	columnName,
		dafBase::DateTime *	location,
		bool	isExpr
	)

Definition at line 607 of file DbStorageImpl.cc.

                                                  {
    std::string col = isExpr ? columnName : quote(columnName);
    _outColumns.push_back(col);
    size_t size = sizeof(MYSQL_TIME);
    std::pair<BoundVarMap::iterator, bool> pair = _outputVars.insert(
        BoundVarMap::value_type(
            col, BoundVar(allocateMemory(size + sizeof(dafBase::DateTime*)))));
    if (!pair.second) {
        error("Duplicate column name requested: " + columnName, false);
    }
    BoundVar& bv = pair.first->second;
    *reinterpret_cast<dafBase::DateTime**>(bv._data) = location;
    bv._type = BoundVarTraits<dafBase::DateTime>::mysqlType;
    bv._isNull = false;
    bv._isUnsigned = BoundVarTraits<dafBase::DateTime>::isUnsigned;
    bv._length = size;
}

query()

void lsst::daf::persistence::DbStorageImpl::query ( void  )

privatevirtual

Execute the query.

Definition at line 669 of file DbStorageImpl.cc.

                                    {
    if (_outColumns.empty()) error("No output columns for query", false);

    // SELECT outVars FROM queryTables WHERE whereClause GROUP BY groupBy
    // ORDER BY orderBy

    // SELECT clause
    std::string query = "SELECT ";
    for (std::vector<std::string>::const_iterator it = _outColumns.begin();
         it != _outColumns.end(); ++it) {
        if (it != _outColumns.begin()) {
            query += ", ";
        }
        query += *it;
    }

    // FROM clause
    query += " FROM ";
    for (std::vector<std::string>::const_iterator it = _queryTables.begin();
         it != _queryTables.end(); ++it) {
        if (it != _queryTables.begin()) {
            query += ", ";
        }
        query += *it;
    }

    // WHERE clause
    std::vector<std::string> whereBindings;
    if (!_whereClause.empty()) {
        boost::regex re(":([A-Za-z_]+)");
        std::string result;
        std::back_insert_iterator<std::string> out(result);
        boost::regex_iterator<std::string::iterator> m; 
        for (boost::regex_iterator<std::string::iterator> i(
                _whereClause.begin(), _whereClause.end(), re);
             i != boost::regex_iterator<std::string::iterator>(); ++i) {
            m = i;
            std::copy(m->prefix().first, m->prefix().second, out);
            *out++ = '?';
            assert(m->size() == 2);
            whereBindings.push_back(m->str(1));
        }
        if (m != boost::regex_iterator<std::string::iterator>()) {
            std::copy(m->suffix().first, m->suffix().second, out);
        }
        else {
            std::copy(_whereClause.begin(), _whereClause.end(), out);
        }
        query += " WHERE " + result;
    }

    // GROUP BY clause
    if (!_groupBy.empty()) query += " GROUP BY " + _groupBy;

    // ORDER BY clause
    if (!_orderBy.empty()) query += " ORDER BY " + _orderBy;


    // Create bindings for input WHERE clause variables, if any

    std::unique_ptr<MYSQL_BIND[]> inBinder(
        new MYSQL_BIND[whereBindings.size()]);
    memset(inBinder.get(), 0, whereBindings.size() * sizeof(MYSQL_BIND));
    for (size_t i = 0; i < whereBindings.size(); ++i) {
        MYSQL_BIND& bind(inBinder[i]);
        BoundVarMap::iterator it = _inputVars.find(whereBindings[i]);
        if (it == _inputVars.end()) {
            error("Unbound variable in WHERE clause: " + whereBindings[i],
                  false);
        }
        BoundVar& bv = it->second;
        bind.buffer_type = bv._type;
        bind.buffer = bv._data;
        bind.buffer_length = bv._length;
        bind.is_null = 0;
        bind.is_unsigned = bv._isUnsigned;
        bind.error = 0;
    }


    // Initialize and prepare statement

    _statement = mysql_stmt_init(_db);
    if (!_statement) {
        error("Unable to initialize prepared statement");
    }

    if (mysql_stmt_prepare(_statement, query.c_str(), query.length()) != 0) {
        stError("Unable to prepare statement: " + query);
    }


    // Check number of input parameters and bind them
    unsigned int params = mysql_stmt_param_count(_statement);
    if (_whereClause.empty()) {
        if (params != 0) {
            error("Unbound WHERE clause parameters: " + query, false);
        }
    }
    else {
        if (params != whereBindings.size()) {
            error("Mismatch in number of WHERE clause parameters: " + query,
                  false);
        }
        if (mysql_stmt_bind_param(_statement, inBinder.get())) {
            stError("Unable to bind WHERE parameters: " + query);
        }
    }

    // Check number of result columns
    MYSQL_RES* queryMetadata = mysql_stmt_result_metadata(_statement);
    if (!queryMetadata) {
        stError("No query metadata: " + query);
    }
    _numResultFields = mysql_num_fields(queryMetadata);
    if (static_cast<unsigned int>(_numResultFields) != _outColumns.size()) {
        error("Mismatch in number of SELECT items: " + query, false);
    }


    // Execute query

    if (mysql_stmt_execute(_statement) != 0) {
        stError("MySQL query failed: " + query);
    }


    // Create bindings for output variables

    _resultFields = mysql_fetch_fields(queryMetadata);

    std::unique_ptr<MYSQL_BIND[]> outBinder(new MYSQL_BIND[_numResultFields]);
    memset(outBinder.get(), 0, _numResultFields * sizeof(MYSQL_BIND));
    _fieldLengths.reset(new unsigned long[_numResultFields]);
    _fieldNulls.reset(new my_bool[_numResultFields]);

    for (int i = 0; i < _numResultFields; ++i) {
        MYSQL_BIND& bind(outBinder[i]);
        if (_outputVars.empty()) {
            bind.buffer_type = MYSQL_TYPE_STRING;
            bind.buffer = 0;
            bind.buffer_length = 0;
            bind.length = &(_fieldLengths[i]);
            bind.is_null = &(_fieldNulls[i]);
            bind.is_unsigned = (_resultFields[i].flags & UNSIGNED_FLAG) != 0;
            bind.error = 0;
        }
        else {
            BoundVarMap::iterator it = _outputVars.find(_outColumns[i]);
            if (it == _outputVars.end()) {
                error("Unbound variable in SELECT clause: " + _outColumns[i],
                      false);
            }
            BoundVar& bv = it->second;

            bind.buffer_type = bv._type;
            if (bv._type == BoundVarTraits<std::string>::mysqlType) {
                bind.buffer = reinterpret_cast<char*>(bv._data) +
                    sizeof(std::string*);
            }
            else if (bv._type == BoundVarTraits<dafBase::DateTime>::mysqlType) {
                bind.buffer = reinterpret_cast<char*>(bv._data) +
                    sizeof(std::string*);
            }
            else {
                bind.buffer = bv._data;
            }
            bind.buffer_length = bv._length;
            bind.length = &(_fieldLengths[i]);
            bind.is_null = &(_fieldNulls[i]);
            bind.is_unsigned = bv._isUnsigned;
            bind.error = 0;
        }
    }
    if (mysql_stmt_bind_result(_statement, outBinder.get())) {
        stError("Unable to bind results: " + query);
    }
}

quote()

std::string lsst::daf::persistence::DbStorageImpl::quote ( std::string const &  name )

private

Quote a name in ANSI-standard fashion.

Definition at line 269 of file DbStorageImpl.cc.

                                                          {
    std::string::size_type pos = name.find('.');
    if (pos == std::string::npos) return '`' + name + '`';
    return '`' + std::string(name, 0, pos) + "`.`" +
        std::string(name, pos + 1) + '`';
}

repr()

std::string lsst::daf::base::Citizen::repr ( ) const

inherited

Return a string representation of a Citizen.

Definition at line 245 of file Citizen.cc.

                                     {
    return boost::str(boost::format("%d: %08x %s")
                      % _CitizenId
                      % this
                      % lsst::utils::demangleType(_typeName)
                     );
}

setColumn() [1/3]

template<typename T >

void lsst::daf::persistence::DbStorageImpl::setColumn ( std::string const &  columnName, T const &  value  )

private

Set the value to insert in a given column.

Parameters

[in]	columnName	Name of the column
[in]	value	Value to set in the column

Definition at line 355 of file DbStorageImpl.cc.

                                                      {
    BoundVarMap::iterator bv = _inputVars.find(columnName);
    size_t size = sizeof(T);
    if (bv == _inputVars.end()) {
       bv = _inputVars.insert(
            BoundVarMap::value_type(columnName,
                                    BoundVar(allocateMemory(size)))).first;
    }
    else if (bv->second._length != size) {
        bv->second._data = allocateMemory(size);
    }
    bv->second._type = BoundVarTraits<T>::mysqlType;
    bv->second._isNull = false;
    bv->second._isUnsigned = BoundVarTraits<T>::isUnsigned;
    bv->second._length = size;
    memcpy(bv->second._data, &value, size);
}

setColumn() [2/3]

template<>

void lsst::daf::persistence::DbStorageImpl::setColumn	(	std::string const &	columnName,
		std::string const &	value
	)

Definition at line 375 of file DbStorageImpl.cc.

                                                              {
    BoundVarMap::iterator bv = _inputVars.find(columnName);
    size_t size = value.length();
    if (bv == _inputVars.end()) {
       bv = _inputVars.insert(
            BoundVarMap::value_type(columnName,
                                    BoundVar(allocateMemory(size)))).first;
    }
    else if (bv->second._length != size) {
        bv->second._data = allocateMemory(size);
    }
    bv->second._type = BoundVarTraits<std::string>::mysqlType;
    bv->second._isNull = false;
    bv->second._isUnsigned = BoundVarTraits<std::string>::isUnsigned;
    bv->second._length = size;
    memcpy(bv->second._data, value.data(), size);
}

setColumn() [3/3]

template<>

void lsst::daf::persistence::DbStorageImpl::setColumn	(	std::string const &	columnName,
		dafBase::DateTime const &	value
	)

Definition at line 395 of file DbStorageImpl.cc.

                                                                    {
    BoundVarMap::iterator bv = _inputVars.find(columnName);
    size_t size = sizeof(MYSQL_TIME);
    if (bv == _inputVars.end()) {
       bv = _inputVars.insert(
            BoundVarMap::value_type(columnName,
                                    BoundVar(allocateMemory(size)))).first;
    }
    else if (bv->second._length != size) {
        bv->second._data = allocateMemory(size);
    }
    bv->second._type = BoundVarTraits<dafBase::DateTime>::mysqlType;
    bv->second._isNull = false;
    bv->second._isUnsigned = BoundVarTraits<dafBase::DateTime>::isUnsigned;
    bv->second._length = size;
    struct tm v = value.gmtime(dafBase::DateTime::UTC);
    MYSQL_TIME* t = reinterpret_cast<MYSQL_TIME*>(bv->second._data);
    t->year = v.tm_year + 1900;
    t->month = v.tm_mon + 1;
    t->day = v.tm_mday;
    t->hour = v.tm_hour;
    t->minute = v.tm_min;
    t->second = v.tm_sec;
    t->neg = false;
    t->second_part =
        static_cast<unsigned long>((value.nsecs() % 1000000000LL) / 1000);
}

setColumnToNull()

void lsst::daf::persistence::DbStorageImpl::setColumnToNull ( std::string const &  columnName )

privatevirtual

Set a given column to NULL.

Parameters

[in]

columnName

Name of the column

Definition at line 427 of file DbStorageImpl.cc.

                                                                     {
    BoundVarMap::iterator bv = _inputVars.find(columnName);
    if (bv == _inputVars.end()) {
       bv = _inputVars.insert(
            BoundVarMap::value_type(columnName,
                                    BoundVar(allocateMemory(1)))).first;
    }
    bv->second._isNull = true;
    bv->second._length = 1;
}

setCorruptionCallback()

dafBase::Citizen::memCallback lsst::daf::base::Citizen::setCorruptionCallback ( Citizen::memCallback  func )

staticinherited

Set the CorruptionCallback function.

Parameters

func	function be called when block is found to be corrupted

Definition at line 432 of file Citizen.cc.

                                                     {
    Citizen::memCallback old = _corruptionCallback;
    _corruptionCallback = func;

    return old;
}

setDeleteCallback()

dafBase::Citizen::memCallback lsst::daf::base::Citizen::setDeleteCallback ( Citizen::memCallback  func )

staticinherited

Set the DeleteCallback function.

Parameters

func	function be called when desired block is deleted

Definition at line 422 of file Citizen.cc.

      {
    Citizen::memCallback old = _deleteCallback;
    _deleteCallback = func;

    return old;
}

setDeleteCallbackId()

dafBase::Citizen::memId lsst::daf::base::Citizen::setDeleteCallbackId ( Citizen::memId  id )

staticinherited

Call the current DeleteCallback when block is deleted.

Parameters

id	Desired ID

Definition at line 387 of file Citizen.cc.

      {
    WriteGuard guard(citizenLock);
    Citizen::memId oldId = _deleteId;
    _deleteId = id;

    return oldId;
}

setNewCallback()

dafBase::Citizen::memNewCallback lsst::daf::base::Citizen::setNewCallback ( Citizen::memNewCallback  func )

staticinherited

Set the NewCallback function.

Parameters

func	The new function to be called when a designated block is allocated

Definition at line 412 of file Citizen.cc.

      {
    Citizen::memNewCallback old = _newCallback;
    _newCallback = func;

    return old;
}

setNewCallbackId()

dafBase::Citizen::memId lsst::daf::base::Citizen::setNewCallbackId ( Citizen::memId  id )

staticinherited

Call the NewCallback when block is allocated.

Parameters

id	Desired ID

Definition at line 376 of file Citizen.cc.

      {
    WriteGuard guard(citizenLock);
    Citizen::memId oldId = _newId;
    _newId = id;

    return oldId;
}

setPersistLocation()

void lsst::daf::persistence::DbStorageImpl::setPersistLocation ( LogicalLocation const &  location )

privatevirtual

Set the database location to persist to.

Parameters

[in]

location

Database connection string to insert into

Definition at line 221 of file DbStorageImpl.cc.

                                                                            {
    startSession(location.locString());
    _readonly = false;
}

setPolicy()

void lsst::daf::persistence::DbStorageImpl::setPolicy ( pexPolicy::Policy::Ptr  policy )

privatevirtual

Allow a Policy to be used to configure the DbStorage.

Parameters

[in]

policy

Definition at line 185 of file DbStorageImpl.cc.

                                                             {
}

setQueryWhere()

void lsst::daf::persistence::DbStorageImpl::setQueryWhere ( std::string const &  whereClause )

privatevirtual

Set the condition for the WHERE clause of the query.

Parameters

[in]

whereClause

SQL text of the WHERE clause

May include join conditions.

Definition at line 663 of file DbStorageImpl.cc.

                                                                    {
    _whereClause = whereClause;
}

setRetrieveLocation()

void lsst::daf::persistence::DbStorageImpl::setRetrieveLocation ( LogicalLocation const &  location )

privatevirtual

Set the database location to retrieve from.

Parameters

[in]

location

Database connection string to query

Definition at line 229 of file DbStorageImpl.cc.

                                                                             {
    startSession(location.locString());
    _readonly = true;
}

setTableForInsert()

void lsst::daf::persistence::DbStorageImpl::setTableForInsert ( std::string const &  tableName )

privatevirtual

Set the table to insert rows into.

Parameters

[in]

tableName

Name of the table

Definition at line 342 of file DbStorageImpl.cc.

                                                                      {
    if (_readonly) {
        error("Attempt to insert into read-only database", false);
    }
    _insertTable = tableName;
    _inputVars.clear();
}

setTableForQuery()

void lsst::daf::persistence::DbStorageImpl::setTableForQuery ( std::string const &  tableName, bool  isExpr  )

privatevirtual

Set the table to query (single-table queries only).

Parameters

[in]	tableName	Name of the table
[in]	isExpr	True if the name is actually a table expression

Definition at line 514 of file DbStorageImpl.cc.

                                                          {
    if (_db == 0) error("Database session not initialized in DbStorage::setTableForQuery()", false);
    _queryTables.clear();
    _queryTables.push_back(isExpr ? tableName : quote(tableName));
    _inputVars.clear();
    _outputVars.clear();
    _outColumns.clear();
    _whereClause.clear();
    _groupBy.clear();
    _orderBy.clear();
    _statement = 0;
}

setTableListForQuery()

void lsst::daf::persistence::DbStorageImpl::setTableListForQuery ( std::vector< std::string > const &  tableNameList )

privatevirtual

Set a list of tables to query (multiple-table queries).

Parameters

[in]

tableNameList

Vector of names of tables

Definition at line 531 of file DbStorageImpl.cc.

                                               {
    if (_db == 0) error("Database session not initialized in DbStorage::setTableListForQuery()", false);
    for (std::vector<std::string>::const_iterator it = tableNameList.begin();
         it != tableNameList.end(); ++it) {
        _queryTables.push_back(quote(*it));
    }
    _inputVars.clear();
    _outputVars.clear();
    _outColumns.clear();
    _whereClause.clear();
    _groupBy.clear();
    _orderBy.clear();
    _statement = 0;
}

startSession()

void lsst::daf::persistence::DbStorageImpl::startSession ( std::string const &  location )

privatevirtual

Start a database session.

Parameters

[in]	location	Physical database location
[in]	am	Access mode for the database (ReadOnly or Update)

Definition at line 196 of file DbStorageImpl.cc.

                                                                {
    // Set the timezone for any DATE/TIME/TIMESTAMP fields.
    setenv("TZ", "UTC", 1);

    DbStorageLocation dbloc(location);

    if (_db) {
        mysql_close(_db);
    }
    _db = mysql_init(0);

    unsigned int port = strtoul(dbloc.getPort().c_str(), 0, 10);
    if (mysql_real_connect(_db,
                           dbloc.getHostname().c_str(),
                           dbloc.getUsername().c_str(),
                           dbloc.getPassword().c_str(),
                           dbloc.getDbName().c_str(),
                           port, 0, 0) == 0) {
        error("Unable to connect to MySQL database: " + _location);
    }
}

startTransaction()

void lsst::daf::persistence::DbStorageImpl::startTransaction ( void  )

privatevirtual

Start a transaction.

Definition at line 236 of file DbStorageImpl.cc.

                                               {
    if (_db == 0) error("Database session not initialized "
                        "in DbStorage::startTransaction()", false);
    if (mysql_autocommit(_db, false)) error("Unable to turn off autocommit");
}

stError()

void lsst::daf::persistence::DbStorageImpl::stError ( std::string const &  text )

private

Definition at line 276 of file DbStorageImpl.cc.

                                                       {
    error(text + " - * " + mysql_stmt_error(_statement), false);
}

truncateTable()

void lsst::daf::persistence::DbStorageImpl::truncateTable ( std::string const &  tableName )

privatevirtual

Truncate a table.

Parameters

[in]

tableName

Name of the table to truncate

Definition at line 323 of file DbStorageImpl.cc.

                                                                  {
    executeQuery("TRUNCATE TABLE " + quote(tableName));
}

Friends And Related Function Documentation

DbStorage

friend class DbStorage

friend

Definition at line 85 of file DbStorageImpl.h.

Member Data Documentation

_bindingMemory

std::vector< boost::shared_array<char> > lsst::daf::persistence::DbStorageImpl::_bindingMemory

private

Memory for bound variables.

Definition at line 155 of file DbStorageImpl.h.

_db

MYSQL* lsst::daf::persistence::DbStorageImpl::_db

private

MySQL database connection pointer.

Definition at line 141 of file DbStorageImpl.h.

_fieldLengths

boost::shared_array<unsigned long> lsst::daf::persistence::DbStorageImpl::_fieldLengths

private

Space for lengths of result fields.

Definition at line 170 of file DbStorageImpl.h.

_fieldNulls

boost::shared_array<my_bool> lsst::daf::persistence::DbStorageImpl::_fieldNulls

private

Space for null flags of result fields.

Definition at line 172 of file DbStorageImpl.h.

_groupBy

std::string lsst::daf::persistence::DbStorageImpl::_groupBy

private

Definition at line 161 of file DbStorageImpl.h.

_inputVars

BoundVarMap lsst::daf::persistence::DbStorageImpl::_inputVars

private

Input variable bindings.

Definition at line 151 of file DbStorageImpl.h.

_insertTable

std::string lsst::daf::persistence::DbStorageImpl::_insertTable

private

Name of table into which to insert.

Definition at line 144 of file DbStorageImpl.h.

_location

std::string lsst::daf::persistence::DbStorageImpl::_location

private

Database location string saved for use by raw MySQL interface.

Definition at line 139 of file DbStorageImpl.h.

_numResultFields

int lsst::daf::persistence::DbStorageImpl::_numResultFields

private

Number of result fields.

Definition at line 168 of file DbStorageImpl.h.

_orderBy

std::string lsst::daf::persistence::DbStorageImpl::_orderBy

private

Definition at line 162 of file DbStorageImpl.h.

_outColumns

std::vector<std::string> lsst::daf::persistence::DbStorageImpl::_outColumns

private

Definition at line 159 of file DbStorageImpl.h.

_outputVars

BoundVarMap lsst::daf::persistence::DbStorageImpl::_outputVars

private

Output variable bindings.

Definition at line 153 of file DbStorageImpl.h.

_queryTables

std::vector<std::string> lsst::daf::persistence::DbStorageImpl::_queryTables

private

Names of tables to select from.

Definition at line 146 of file DbStorageImpl.h.

_readonly

bool lsst::daf::persistence::DbStorageImpl::_readonly

private

Remember if we are supposed to be read-only.

Definition at line 137 of file DbStorageImpl.h.

_resultFields

MYSQL_FIELD* lsst::daf::persistence::DbStorageImpl::_resultFields

private

Query result field metadata.

Definition at line 166 of file DbStorageImpl.h.

_statement

MYSQL_STMT* lsst::daf::persistence::DbStorageImpl::_statement

private

Prepared query statement.

Definition at line 164 of file DbStorageImpl.h.

_whereClause

std::string lsst::daf::persistence::DbStorageImpl::_whereClause

private

Definition at line 160 of file DbStorageImpl.h.

---

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

• /home/jenkins-slave/snowflake/release/lsstsw/stack/Linux64/daf_persistence/15.0/include/lsst/daf/persistence/DbStorageImpl.h
• /home/jenkins-slave/snowflake/release/lsstsw/stack/Linux64/daf_persistence/15.0/src/DbStorageImpl.cc