DbStorage.cc

Go to the documentation of this file.

// -*- lsst-c++ -*-

/* 
 * LSST Data Management System
 * Copyright 2008, 2009, 2010 LSST Corporation.
 * 
 * This product includes software developed by the
 * LSST Project (http://www.lsst.org/).
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the LSST License Statement and 
 * the GNU General Public License along with this program.  If not, 
 * see <http://www.lsstcorp.org/LegalNotices/>.
 */
 

#ifndef __GNUC__
#  define __attribute__(x) /*NOTHING*/
#endif
static char const* SVNid __attribute__((unused)) = "$Id$";

#include "lsst/daf/base/DateTime.h"
#include "lsst/daf/persistence/DbStorage.h"
#include "lsst/daf/persistence/DbStorageImpl.h"

using lsst::daf::base::DateTime;

namespace lsst {
namespace daf {
namespace persistence {

DbStorage::DbStorage(void) : Storage(typeid(*this)), _impl(new DbStorageImpl) {
}

DbStorage::DbStorage(std::type_info const& type) :
    Storage(type), _impl(new DbStorageImpl) {
}

DbStorage::~DbStorage(void) {
}

void DbStorage::setPolicy(lsst::pex::policy::Policy::Ptr policy) {
    _impl->setPolicy(policy);
}

void DbStorage::setPersistLocation(LogicalLocation const& location) {
    _impl->setPersistLocation(location);
}

void DbStorage::setRetrieveLocation(LogicalLocation const& location) {
    _impl->setRetrieveLocation(location);
}

void DbStorage::startTransaction(void) {
    _impl->startTransaction();
}

void DbStorage::endTransaction(void) {
    _impl->endTransaction();
}

void DbStorage::createTableFromTemplate(std::string const& tableName,
                                        std::string const& templateName,
                                        bool mayAlreadyExist) {
    _impl->createTableFromTemplate(tableName, templateName, mayAlreadyExist);
}

void DbStorage::dropTable(std::string const& tableName) {
    _impl->dropTable(tableName);
}

void DbStorage::truncateTable(std::string const& tableName) {
    _impl->truncateTable(tableName);
}

void DbStorage::executeSql(std::string const& sqlStatement) {
    _impl->executeSql(sqlStatement);
}

void DbStorage::setTableForInsert(std::string const& tableName) {
    _impl->setTableForInsert(tableName);
}

template <typename T>
void DbStorage::setColumn(std::string const& columnName, T const& value) {
    _impl->setColumn(columnName, value);
}

void DbStorage::setColumnToNull(std::string const& columnName) {
    _impl->setColumnToNull(columnName);
}

void DbStorage::insertRow(void) {
    _impl->insertRow();
}


void DbStorage::setTableForQuery(std::string const& tableName, bool isExpr) {
    _impl->setTableForQuery(tableName, isExpr);
}

void DbStorage::setTableListForQuery(
    std::vector<std::string> const& tableNameList) {
    _impl->setTableListForQuery(tableNameList);
}

void DbStorage::outColumn(std::string const& columnName, bool isExpr) {
    _impl->outColumn(columnName, isExpr);
}

template <typename T>
void DbStorage::outParam(std::string const& columnName, T* location,
                         bool isExpr) {
    _impl->outParam(columnName, location, isExpr);
}

template <typename T>
void DbStorage::condParam(std::string const& paramName, T const& value) {
    _impl->condParam(paramName, value);
}

void DbStorage::orderBy(std::string const& expression) {
    _impl->orderBy(expression);
}

void DbStorage::groupBy(std::string const& expression) {
    _impl->groupBy(expression);
}

void DbStorage::setQueryWhere(std::string const& whereClause) {
    _impl->setQueryWhere(whereClause);
}

void DbStorage::query(void) {
    _impl->query();
}

bool DbStorage::next(void) {
    return _impl->next();
}

template <typename T>
T const& DbStorage::getColumnByPos(int pos) {
    return _impl->getColumnByPos<T>(pos);
}

bool DbStorage::columnIsNull(int pos) {
    return _impl->columnIsNull(pos);
}

void DbStorage::finishQuery(void) {
    _impl->finishQuery();
}

// Explicit template member function instantiations.
// Ignore for doxygen processing.
template void DbStorage::setColumn<>(std::string const& columnName, char const& value);
template void DbStorage::setColumn<>(std::string const& columnName, short const& value);
template void DbStorage::setColumn<>(std::string const& columnName, int const& value);
template void DbStorage::setColumn<>(std::string const& columnName, long const& value);
template void DbStorage::setColumn<>(std::string const& columnName, long long const& value);
template void DbStorage::setColumn<>(std::string const& columnName, float const& value);
template void DbStorage::setColumn<>(std::string const& columnName, double const& value);
template void DbStorage::setColumn<>(std::string const& columnName, std::string const& value);
template void DbStorage::setColumn<>(std::string const& columnName, bool const& value);
template void DbStorage::setColumn<>(std::string const& columnName, DateTime const& value);

template void DbStorage::outParam<>(std::string const& columnName, char* location, bool isExpr);
template void DbStorage::outParam<>(std::string const& columnName, short* location, bool isExpr);
template void DbStorage::outParam<>(std::string const& columnName, int* location, bool isExpr);
template void DbStorage::outParam<>(std::string const& columnName, long* location, bool isExpr);
template void DbStorage::outParam<>(std::string const& columnName, long long* location, bool isExpr);
template void DbStorage::outParam<>(std::string const& columnName, float* location, bool isExpr);
template void DbStorage::outParam<>(std::string const& columnName, double* location, bool isExpr);
template void DbStorage::outParam<>(std::string const& columnName, std::string* location, bool isExpr);
template void DbStorage::outParam<>(std::string const& columnName, bool* location, bool isExpr);
template void DbStorage::outParam<>(std::string const& columnName, DateTime* location, bool isExpr);

template void DbStorage::condParam<>(std::string const& paramName, char const& value);
template void DbStorage::condParam<>(std::string const& paramName, short const& value);
template void DbStorage::condParam<>(std::string const& paramName, int const& value);
template void DbStorage::condParam<>(std::string const& paramName, long const& value);
template void DbStorage::condParam<>(std::string const& paramName, long long const& value);
template void DbStorage::condParam<>(std::string const& paramName, float const& value);
template void DbStorage::condParam<>(std::string const& paramName, double const& value);
template void DbStorage::condParam<>(std::string const& paramName, std::string const& value);
template void DbStorage::condParam<>(std::string const& paramName, bool const& value);
template void DbStorage::condParam<>(std::string const& paramName, DateTime const& value);

template char const& DbStorage::getColumnByPos<>(int pos);
template short const& DbStorage::getColumnByPos<>(int pos);
template int const& DbStorage::getColumnByPos<>(int pos);
template long const& DbStorage::getColumnByPos<>(int pos);
template long long const& DbStorage::getColumnByPos<>(int pos);
template float const& DbStorage::getColumnByPos<>(int pos);
template double const& DbStorage::getColumnByPos<>(int pos);
template std::string const& DbStorage::getColumnByPos<>(int pos);
template bool const& DbStorage::getColumnByPos<>(int pos);
template DateTime const& DbStorage::getColumnByPos<>(int pos);

}}} // namespace lsst::daf::persistence