pgsql_connection.h

Go to the documentation of this file.

// Copyright (C) 2016-2018 Internet Systems Consortium, Inc. ("ISC")
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef PGSQL_CONNECTION_H
#define PGSQL_CONNECTION_H
 
#include <database/database_connection.h>
 
#include <libpq-fe.h>
#include <boost/scoped_ptr.hpp>
 
#include <vector>
#include <stdint.h>
 
namespace isc {
namespace db {
 
const uint32_t PG_SCHEMA_VERSION_MAJOR = 5;
const uint32_t PG_SCHEMA_VERSION_MINOR = 0;
 
// Maximum number of parameters that can be used a statement
// @todo This allows us to use an initializer list (since we can't
// require C++11).  It's unlikely we'd go past this many a single
// statement.
const size_t PGSQL_MAX_PARAMETERS_IN_QUERY = 32;
 
struct PgSqlTaggedStatement {
    int nbparams;
 
    const Oid types[PGSQL_MAX_PARAMETERS_IN_QUERY];
 
    const char* name;
 
    const char* text;
};
 
const size_t OID_NONE = 0;   // PostgreSQL infers proper type
const size_t OID_BOOL = 16;
const size_t OID_BYTEA = 17;
const size_t OID_INT8 = 20;  // 8 byte int
const size_t OID_INT2 = 21;  // 2 byte int
const size_t OID_INT4 = 23;  // 4 byte int
const size_t OID_TEXT = 25;
const size_t OID_VARCHAR = 1043;
const size_t OID_TIMESTAMP = 1114;
 
 
 
class PgSqlResult : public boost::noncopyable {
public:
    PgSqlResult(PGresult *result);
 
    ~PgSqlResult();
 
    int getRows() const {
        return (rows_);
    }
 
    int getCols() const {
        return (cols_);
    }
 
    void rowCheck(int row) const;
 
    void colCheck(int col) const;
 
    void rowColCheck(int row, int col) const;
 
    std::string getColumnLabel(const int col) const;
 
    operator PGresult*() const {
        return (result_);
    }
 
    operator bool() const {
        return (result_);
    }
 
private:
    PGresult*     result_;     
    int rows_;   
    int cols_;   
};
 
 
class PgSqlHolder : public boost::noncopyable {
public:
 
    PgSqlHolder() : pgconn_(NULL) {
    }
 
    ~PgSqlHolder() {
        if (pgconn_ != NULL) {
            PQfinish(pgconn_);
        }
    }
 
    void setConnection(PGconn* connection) {
        if (pgconn_ != NULL) {
            // Already set? Release the current connection first.
            // Maybe this should be an error instead?
            PQfinish(pgconn_);
        }
 
        pgconn_ = connection;
    }
 
    operator PGconn*() const {
        return (pgconn_);
    }
 
    operator bool() const {
        return (pgconn_);
    }
 
private:
    PGconn* pgconn_;      
};
 
class PgSqlConnection;
 
class PgSqlTransaction : public boost::noncopyable {
public:
 
    PgSqlTransaction(PgSqlConnection& conn);
 
    ~PgSqlTransaction();
 
    void commit();
 
private:
 
    PgSqlConnection& conn_;
 
    bool committed_;
};
 
class PgSqlConnection : public db::DatabaseConnection {
public:
    static const char DUPLICATE_KEY[];
 
    PgSqlConnection(const ParameterMap& parameters)
        : DatabaseConnection(parameters) {
    }
 
    virtual ~PgSqlConnection();
 
    void prepareStatement(const PgSqlTaggedStatement& statement);
 
    void prepareStatements(const PgSqlTaggedStatement* start_statement,
                           const PgSqlTaggedStatement* end_statement);
 
    void openDatabase();
 
    void startTransaction();
 
    void commit();
 
    void rollback();
 
    bool compareError(const PgSqlResult& r, const char* error_state);
 
    void checkStatementError(const PgSqlResult& r,
                             PgSqlTaggedStatement& statement) const;
 
    PgSqlHolder conn_;
 
    operator PGconn*() const {
        return (conn_);
    }
 
    operator bool() const {
        return (conn_);
    }
 
};
 
}; // end of isc::db namespace
}; // end of isc namespace
 
#endif // PGSQL_CONNECTION_H