pgsql_exchange.h

Go to the documentation of this file.

// Copyright (C) 2016-2018,2021 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_EXCHANGE_H
#define PGSQL_EXCHANGE_H

#include <asiolink/io_address.h>
#include <pgsql/pgsql_connection.h>

#include <boost/lexical_cast.hpp>
#include <boost/noncopyable.hpp>
#include <boost/shared_ptr.hpp>

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

namespace isc {
namespace db {

typedef boost::shared_ptr<const std::string> ConstStringPtr;

struct PsqlBindArray {
    std::vector<const char *> values_;
    std::vector<int> lengths_;
    std::vector<int> formats_;

    static const int TEXT_FMT;
    static const int BINARY_FMT;

    static const char* TRUE_STR;
    static const char* FALSE_STR;

    size_t size() const {
        return (values_.size());
    }

    bool empty() const {

        return (values_.empty());
    }

    void add(const char* value);

    void add(const std::string& value);

    void add(const std::vector<uint8_t>& data);

    void add(const uint8_t* data, const size_t len);

    void add(const bool& value);

    void add(const uint8_t& byte);

    void add(const isc::asiolink::IOAddress& addr);

    template<typename T>
    void add(const T& value) {
        addTempString(boost::lexical_cast<std::string>(value));
    }

    void addTempString(const std::string& str);

    void addNull(const int format = PsqlBindArray::TEXT_FMT);

    //std::vector<const std::string> getBoundStrs() {
    std::vector<ConstStringPtr> getBoundStrs() {
        return (bound_strs_);
    }

    std::string toText() const;

private:
    std::vector<ConstStringPtr> bound_strs_;

};

typedef boost::shared_ptr<PsqlBindArray> PsqlBindArrayPtr;

class PgSqlExchange {
public:
    PgSqlExchange(const size_t num_columns = 0) : columns_(num_columns) {}

    virtual ~PgSqlExchange(){}

    static std::string convertToDatabaseTime(const time_t input_time);

    static std::string convertToDatabaseTime(const time_t cltt,
                                             const uint32_t valid_lifetime);

    static time_t convertFromDatabaseTime(const std::string& db_time_val);

    static const char* getRawColumnValue(const PgSqlResult& r, const int row,
                                         const size_t col);

    static std::string getColumnLabel(const PgSqlResult& r, const size_t col);

    static void getColumnValue(const PgSqlResult& r, const int row,
                               const size_t col, std::string& value);

    static void getColumnValue(const PgSqlResult& r, const int row,
                               const size_t col, bool &value);

    static void getColumnValue(const PgSqlResult& r, const int row,
                               const size_t col, uint8_t &value);

    static isc::asiolink::IOAddress getIPv6Value(const PgSqlResult& r,
                                                 const int row,
                                                 const size_t col);

    static bool isColumnNull(const PgSqlResult& r, const int row,
                             const size_t col);

    template<typename T>
    static void getColumnValue(const PgSqlResult& r, const int row,
                               const size_t col, T& value) {
        const char* data = getRawColumnValue(r, row, col);
        try {
            value = boost::lexical_cast<T>(data);
        } catch (const std::exception& ex) {
            isc_throw(db::DbOperationError, "Invalid data:[" << data
                      << "] for row: " << row << " col: " << col << ","
                      << getColumnLabel(r, col) << " : " << ex.what());
        }
    }

    static void convertFromBytea(const PgSqlResult& r, const int row,
                                 const size_t col, uint8_t* buffer,
                                 const size_t buffer_size,
                                 size_t &bytes_converted);

    static std::string dumpRow(const PgSqlResult& r, int row);

protected:
    std::vector<std::string>columns_;
};

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

#endif // PGSQL_EXCHANGE_H