pgsql_connection.h

Go to the documentation of this file.

// Copyright (C) 2016-2023 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 <asiolink/io_service.h>
#include <pgsql/pgsql_exchange.h>

#include <boost/scoped_ptr.hpp>

#include <vector>
#include <stdint.h>

namespace isc {
namespace db {

const uint32_t PGSQL_SCHEMA_VERSION_MAJOR = 13;
const uint32_t PGSQL_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 = 128;

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 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[];
    static const char NULL_KEY[];

    typedef std::function<void(PgSqlResult&, int)> ConsumeResultRowFun;

    static bool warned_about_tls;

    PgSqlConnection(const ParameterMap& parameters,
                    IOServiceAccessorPtr io_accessor = IOServiceAccessorPtr(),
                    DbCallback callback = DbCallback())
        : DatabaseConnection(parameters, callback),
          io_service_accessor_(io_accessor), io_service_(),
          transaction_ref_count_(0) {
    }

    virtual ~PgSqlConnection();

    static std::pair<uint32_t, uint32_t>
    getVersion(const ParameterMap& parameters);

    void prepareStatement(const PgSqlTaggedStatement& statement);

    void prepareStatements(const PgSqlTaggedStatement* start_statement,
                           const PgSqlTaggedStatement* end_statement);

    std::string getConnParameters();

    void openDatabase();

    void startTransaction();

    bool isTransactionStarted() const;

    void commit();

    void rollback();

    void createSavepoint(const std::string& name);

    void rollbackToSavepoint(const std::string& name);

    void executeSQL(const std::string& sql);

    bool compareError(const PgSqlResult& r, const char* error_state);

    void checkStatementError(const PgSqlResult& r,
                             PgSqlTaggedStatement& statement);

    void startRecoverDbConnection() {
        if (callback_) {
            if (!io_service_ && io_service_accessor_) {
                io_service_ = (*io_service_accessor_)();
                io_service_accessor_.reset();
            }

            if (io_service_) {
                io_service_->post(std::bind(callback_, reconnectCtl()));
            }
        }
    }

    PgSqlResultPtr executePreparedStatement(PgSqlTaggedStatement& statement,
                                            const PsqlBindArray& in_bindings
                                            = PsqlBindArray());

    void selectQuery(PgSqlTaggedStatement& statement,
                     const PsqlBindArray& in_bindings,
                     ConsumeResultRowFun process_result_row);

    void insertQuery(PgSqlTaggedStatement& statement,
                     const PsqlBindArray& in_bindings);


    uint64_t updateDeleteQuery(PgSqlTaggedStatement& statement,
                               const PsqlBindArray& in_bindings);

    PgSqlHolder conn_;

    operator PGconn*() const {
        return (conn_);
    }

    operator bool() const {
        return (conn_);
    }

private:

    template<typename T>
    void setIntParameterValue(const std::string& name, int64_t min, int64_t max, T& value);

public:

    IOServiceAccessorPtr io_service_accessor_;

    isc::asiolink::IOServicePtr io_service_;

    int transaction_ref_count_;
};

typedef boost::shared_ptr<PgSqlConnection> PgSqlConnectionPtr;

} // end of isc::db namespace
} // end of isc namespace

#endif // PGSQL_CONNECTION_H