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

Class for implementation of database storage. More...

#include <DbStorageImpl.h>

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

Public Member Functions
virtual	~DbStorageImpl (void)
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)
Public Member Functions inherited from lsst::daf::base::Citizen
	Citizen (const std::type_info &)
	Citizen (Citizen const &)
	~Citizen ()
Citizen &	operator= (Citizen const &)
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...

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

Private Member Functions
	DbStorageImpl (void)
virtual void	setPolicy (pexPolicy::Policy::Ptr policy)
virtual void	setPersistLocation (LogicalLocation const &location)
virtual void	setRetrieveLocation (LogicalLocation const &location)
virtual void	startTransaction (void)
virtual void	endTransaction (void)
virtual void	startSession (std::string const &location)
virtual void	createTableFromTemplate (std::string const &tableName, std::string const &templateName, bool mayAlreadyExist)
virtual void	dropTable (std::string const &tableName)
virtual void	truncateTable (std::string const &tableName)
virtual void	executeSql (std::string const &sqlStatement)
virtual void	setTableForInsert (std::string const &tableName)
template<typename T >
void	setColumn (std::string const &columnName, T const &value)
virtual void	setColumnToNull (std::string const &columnName)
virtual void	insertRow (void)
virtual void	setTableForQuery (std::string const &tableName, bool isExpr)
virtual void	setTableListForQuery (std::vector< std::string > const &tableNameList)
virtual void	outColumn (std::string const &columnName, bool isExpr)
template<typename T >
void	outParam (std::string const &columnName, T *location, bool isExpr)
template<typename T >
void	condParam (std::string const &paramName, T const &value)
virtual void	orderBy (std::string const &expression)
virtual void	groupBy (std::string const &expression)
virtual void	setQueryWhere (std::string const &whereClause)
virtual void	query (void)
virtual bool	next (void)
template<typename T >
T const &	getColumnByPos (int pos)
bool	columnIsNull (int pos)
virtual void	finishQuery (void)
void	executeQuery (std::string const &query)
std::string	quote (std::string const &name)
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

Additional Inherited Members
Public Types inherited from lsst::daf::base::Citizen
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)
Static Public Member Functions inherited from lsst::daf::base::Citizen
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...
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...
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...
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...

Detailed Description

Class for implementation of database storage.

Use via DbStorage class only.

Definition at line 79 of file DbStorageImpl.h.

Member Typedef Documentation

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

private

Definition at line 149 of file DbStorageImpl.h.

Constructor & Destructor Documentation

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

virtual

Destructor. End session if present.

Definition at line 168 of file DbStorageImpl.cc.

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

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

private

Default constructor.

Definition at line 161 of file DbStorageImpl.cc.

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

Member Function Documentation

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

private

Definition at line 283 of file DbStorageImpl.cc.

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

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 979 of file DbStorageImpl.cc.

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

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 627 of file DbStorageImpl.cc.

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

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 298 of file DbStorageImpl.cc.

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

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 310 of file DbStorageImpl.cc.

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

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

privatevirtual

End a transaction.

Definition at line 237 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");
}

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

private

Definition at line 274 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);
    }
}

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

private

Execute a query string.

Definition at line 250 of file DbStorageImpl.cc.

                                                             {
    if (_db == 0) {
        error("No DB connection for query: " + query, false);
    }
    lsst::pex::logging::TTrace<5>("daf.persistence.DbStorage",
                                  "Query: " + query);
    if (mysql_query(_db, query.c_str()) != 0) {
        error("Unable to execute query: " + query);
    }
}

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 325 of file DbStorageImpl.cc.

                                                                  {
    executeQuery(sqlStatement);
}

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

privatevirtual

Indicate that query processing is finished.

Definition at line 990 of file DbStorageImpl.cc.

                                          {
    mysql_stmt_close(_statement);
    _statement = 0;
}

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 890 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;
}

template<>

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

(

int

pos

)

Definition at line 914 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);
    }
    boost::scoped_array<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;
}

template<>

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

(

int

pos

)

Definition at line 943 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;
}

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 645 of file DbStorageImpl.cc.

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

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

privatevirtual

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

Definition at line 435 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) + " (";

    boost::scoped_array<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;
}

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 845 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;
}

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 635 of file DbStorageImpl.cc.

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

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 548 of file DbStorageImpl.cc.

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

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 563 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;
}

template<>

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

Definition at line 581 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;
}

template<>

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

Definition at line 601 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;
}

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

privatevirtual

Execute the query.

Definition at line 663 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

    boost::scoped_array<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);

    boost::scoped_array<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);
    }
}

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

private

Quote a name in ANSI-standard fashion.

Definition at line 263 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) + '`';
}

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 349 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);
}

template<>

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

Definition at line 369 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);
}

template<>

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

Definition at line 389 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();
    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);
}

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 421 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;
}

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 214 of file DbStorageImpl.cc.

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

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 178 of file DbStorageImpl.cc.

                                                             {
}

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 657 of file DbStorageImpl.cc.

                                                                    {
    _whereClause = whereClause;
}

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 222 of file DbStorageImpl.cc.

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

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 336 of file DbStorageImpl.cc.

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

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 508 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;
}

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 525 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;
}

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 189 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);
    }
}

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

privatevirtual

Start a transaction.

Definition at line 229 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");
}

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

private

Definition at line 270 of file DbStorageImpl.cc.

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

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 317 of file DbStorageImpl.cc.

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

Friends And Related Function Documentation

friend class DbStorage

friend

Definition at line 85 of file DbStorageImpl.h.

Member Data Documentation

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

private

Memory for bound variables.

Definition at line 154 of file DbStorageImpl.h.

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

private

MySQL database connection pointer.

Definition at line 141 of file DbStorageImpl.h.

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

private

Space for lengths of result fields.

Definition at line 169 of file DbStorageImpl.h.

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

private

Space for null flags of result fields.

Definition at line 171 of file DbStorageImpl.h.

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

private

Definition at line 160 of file DbStorageImpl.h.

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

private

Input variable bindings.

Definition at line 150 of file DbStorageImpl.h.

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

private

Name of table into which to insert.

Definition at line 144 of file DbStorageImpl.h.

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.

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

private

Number of result fields.

Definition at line 167 of file DbStorageImpl.h.

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

private

Definition at line 161 of file DbStorageImpl.h.

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

private

Definition at line 158 of file DbStorageImpl.h.

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

private

Output variable bindings.

Definition at line 152 of file DbStorageImpl.h.

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

private

Names of tables to select from.

Definition at line 146 of file DbStorageImpl.h.

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

private

Remember if we are supposed to be read-only.

Definition at line 137 of file DbStorageImpl.h.

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

private

Query result field metadata.

Definition at line 165 of file DbStorageImpl.h.

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

private

Prepared query statement.

Definition at line 163 of file DbStorageImpl.h.

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

private

Definition at line 159 of file DbStorageImpl.h.

---

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

• /home/lsstsw/stack/Linux64/daf_persistence/11.0-1-g7418c06/include/lsst/daf/persistence/DbStorageImpl.h
• /home/lsstsw/stack/Linux64/daf_persistence/11.0-1-g7418c06/src/DbStorageImpl.cc