pgsql_exchange.h

Go to the documentation of this file.

// Copyright (C) 2016-2022 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 <database/database_connection.h>
#include <cc/data.h>
#include <util/triplet.h>
#include <util/boost_time_utils.h>
#include <exceptions/exceptions.h>

#include <boost/lexical_cast.hpp>
#include <boost/noncopyable.hpp>
#include <boost/shared_ptr.hpp>
#include <libpq-fe.h>

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

namespace isc {
namespace db {


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

typedef boost::shared_ptr<PgSqlResult> PgSqlResultPtr;

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

struct PsqlBindArray {
    PsqlBindArray() : values_(0), lengths_(0), formats_(0) {}

    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 insert(const char* value, size_t index);

    void insert(const std::string& value, size_t index);

    void popBack();

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

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

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

    void addTempBuffer(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);

    void add(const isc::util::Triplet<uint32_t>& triplet);

    void addMin(const isc::util::Triplet<uint32_t>& triplet);

    void addMax(const isc::util::Triplet<uint32_t>& triplet);

    void addOptional(const util::Optional<std::string>& value);

    template<typename T>
    void addOptional(const util::Optional<T>& value) {
        if (value.unspecified()) {
            addNull();
        } else {
            add(value);
        }
    }

    void addInet4(const isc::asiolink::IOAddress& value);

    void addInet6(const isc::asiolink::IOAddress& value);

    void addOptionalInet4(const util::Optional<isc::asiolink::IOAddress>& value);

    void addOptionalInet6(const util::Optional<isc::asiolink::IOAddress>& value);


    void addTimestamp(const boost::posix_time::ptime& timestamp);

    void addTimestamp();

    void add(const data::ElementPtr& value);

    void add(const data::ConstElementPtr& value);

    std::string toText() const;

    // --- the following methods are mostly useful for testing -----

    bool amNull(size_t index = 0) const;

    template<typename T>
    T getInteger(size_t index = 0) {
        if (values_.size() < index + 1) {
            isc_throw(OutOfRange, "Invalid index " << index << ", the values array has "
                                << values_.size() << " element(s)");
        }
        auto x = values_.at(index);
        if (!x) {
            isc_throw(BadValue, "the data in column " << index << " is null");
        }
        return (boost::lexical_cast<T>(x));
    }

    int getType(size_t index = 0 ) {
        if (formats_.size() < index + 1) {
            isc_throw(OutOfRange, "Invalid index " << index << ", the formats_ array has "
                                << formats_.size() << " element(s)");
        }
        return (formats_.at(index));
    }

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 convertLocalToDatabaseTime(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 void convertFromDatabaseTime(const std::string& db_time_val,
                                        boost::posix_time::ptime& conv_time);

    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 getInetValue4(const PgSqlResult& r,
                                                  const int row,
                                                  const size_t col);

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

    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 getColumnValue(const PgSqlResult& r, const int row,
                               const size_t col, boost::posix_time::ptime& value);

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

    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 void convertFromBytea(const PgSqlResult& r, const int row,
                                 const size_t col, std::vector<uint8_t>& value);

    static isc::util::Triplet<uint32_t> getTripletValue(const PgSqlResult& r,
                                                        const int row,
                                                        const size_t col);

    static isc::util::Triplet<uint32_t> getTripletValue(const PgSqlResult& r,
                                                        const int row,
                                                        const size_t def_col,
                                                        const size_t min_col,
                                                        const size_t max_col);

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

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

class PgSqlResultRowWorker {
public:
    PgSqlResultRowWorker(const PgSqlResult& r, const int row);

    bool isColumnNull(const size_t col);

    std::string getString(const size_t col);

    bool getBool(const size_t col);

    double getDouble(const size_t col);

    const char* getRawColumnValue(const size_t col);

    uint64_t getBigInt(const size_t col);

    uint32_t getInt(const size_t col);

    uint16_t getSmallInt(const size_t col);

    void getBytes(const size_t col, std::vector<uint8_t>& value);

    isc::asiolink::IOAddress getInet4(const size_t col);

    isc::asiolink::IOAddress getInet6(const size_t col);

    template<typename T>
    void getColumnValue(const size_t col, T& value) {
        PgSqlExchange::getColumnValue(r_, row_, col, value);
    }

    boost::posix_time::ptime getTimestamp(const size_t col);

    data::ElementPtr getJSON(const size_t col);

    isc::util::Triplet<uint32_t> getTriplet(const size_t col);

    isc::util::Triplet<uint32_t> getTriplet(const size_t def_col,
                                            const size_t min_col,
                                            const size_t max_col);

    std::string dumpRow();

private:
    const PgSqlResult& r_;

    size_t row_;
};

typedef boost::shared_ptr<PgSqlResultRowWorker> PgSqlResultRowWorkerPtr;

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

#endif // PGSQL_EXCHANGE_H