pgsql_exchange.h

Go to the documentation of this file.

// Copyright (C) 2016-2024 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.get());
        }
    }
 
    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