mysql_binding.h

Go to the documentation of this file.

// Copyright (C) 2018-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 MYSQL_BINDING_H
#define MYSQL_BINDING_H
 
#include <asiolink/io_address.h>
#include <cc/data.h>
#include <database/database_connection.h>
#include <exceptions/exceptions.h>
#include <util/optional.h>
#include <boost/date_time/posix_time/conversion.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
#include <boost/shared_ptr.hpp>
#include <mysql/mysql_constants.h>
#include <mysql.h>
#include <mysqld_error.h>
#include <cstdint>
#include <iterator>
#include <string>
#include <vector>
 
namespace isc {
namespace db {
 
template<typename T>
struct MySqlBindingTraits {
    static const enum_field_types column_type = MYSQL_TYPE_BLOB;
    static const size_t length = 0;
    static const bool am_unsigned = false;
};
 
template<>
struct MySqlBindingTraits<std::string> {
    static const enum_field_types column_type = MYSQL_TYPE_STRING;
    static const size_t length = 0;
    static const bool am_unsigned = false;
};
 
template<>
struct MySqlBindingTraits<boost::posix_time::ptime> {
    static const enum_field_types column_type = MYSQL_TYPE_TIMESTAMP;
    static const size_t length = sizeof(MYSQL_TIME);
    static const bool am_unsignged = false;
};
 
template<>
struct MySqlBindingTraits<int8_t> {
    static const enum_field_types column_type = MYSQL_TYPE_TINY;
    static const size_t length = 1;
    static const bool am_unsigned = false;
};
 
template<>
struct MySqlBindingTraits<uint8_t> {
    static const enum_field_types column_type = MYSQL_TYPE_TINY;
    static const size_t length = 1;
    static const bool am_unsigned = true;
};
 
template<>
struct MySqlBindingTraits<int16_t> {
    static const enum_field_types column_type = MYSQL_TYPE_SHORT;
    static const size_t length = 2;
    static const bool am_unsigned = false;
};
 
template<>
struct MySqlBindingTraits<uint16_t> {
    static const enum_field_types column_type = MYSQL_TYPE_SHORT;
    static const size_t length = 2;
    static const bool am_unsigned = true;
};
 
template<>
struct MySqlBindingTraits<int32_t> {
    static const enum_field_types column_type = MYSQL_TYPE_LONG;
    static const size_t length = 4;
    static const bool am_unsigned = false;
};
 
template<>
struct MySqlBindingTraits<uint32_t> {
    static const enum_field_types column_type = MYSQL_TYPE_LONG;
    static const size_t length = 4;
    static const bool am_unsigned = true;
};
 
template<>
struct MySqlBindingTraits<int64_t> {
    static const enum_field_types column_type = MYSQL_TYPE_LONGLONG;
    static const size_t length = 8;
    static const bool am_unsigned = false;
};
 
template<>
struct MySqlBindingTraits<uint64_t> {
    static const enum_field_types column_type = MYSQL_TYPE_LONGLONG;
    static const size_t length = 8;
    static const bool am_unsigned = true;
};
 
template<>
struct MySqlBindingTraits<float> {
    static const enum_field_types column_type = MYSQL_TYPE_FLOAT;
    static const size_t length = 4;
    static const bool am_unsigned = false;
};
 
class MySqlBinding;
 
typedef boost::shared_ptr<MySqlBinding> MySqlBindingPtr;
 
class MySqlBinding {
public:
 
    enum_field_types getType() const {
        return (bind_.buffer_type);
    }
 
    MYSQL_BIND& getMySqlBinding() {
        return (bind_);
    }
 
    std::string getString() const;
 
    std::string getStringOrDefault(const std::string& default_value) const;
 
    data::ElementPtr getJSON() const;
 
    std::vector<uint8_t> getBlob() const;
 
    std::vector<uint8_t>
    getBlobOrDefault(const std::vector<uint8_t>& default_value) const;
 
    template<typename T>
    T getInteger() const {
        // Make sure that the binding type is numeric.
        validateAccess<T>();
 
        // Convert the buffer to a numeric type and then return a copy.
        const T* value = reinterpret_cast<const T*>(&buffer_[0]);
        return (*value);
    }
 
    template<typename T>
    T getIntegerOrDefault(T default_value) const {
        if (amNull()) {
            return (default_value);
        }
        return (getInteger<T>());
    }
 
    float getFloat() const;
 
    bool getBool() const {
        return (static_cast<bool>(getInteger<uint8_t>()));
    }
 
    boost::posix_time::ptime getTimestamp() const;
 
    boost::posix_time::ptime
    getTimestampOrDefault(const boost::posix_time::ptime& default_value) const;
 
    bool amNull() const {
        return (null_value_ == MLM_TRUE);
    }
 
    static MySqlBindingPtr createString(const unsigned long length);
 
    static MySqlBindingPtr createString(const std::string& value);
 
    static MySqlBindingPtr condCreateString(const util::Optional<std::string>& value);
 
    static MySqlBindingPtr createBlob(const unsigned long length);
 
    template<typename Iterator>
    static MySqlBindingPtr createBlob(Iterator begin, Iterator end) {
        MySqlBindingPtr binding(new MySqlBinding(MYSQL_TYPE_BLOB,
                                                 std::distance(begin, end)));
        binding->setBufferValue(begin, end);
        return (binding);
    }
 
    template<typename T>
    static MySqlBindingPtr createInteger() {
        MySqlBindingPtr binding(new MySqlBinding(MySqlBindingTraits<T>::column_type,
                                                 MySqlBindingTraits<T>::length));
        binding->setValue<T>(0);
        return (binding);
    }
 
    template<typename T>
    static MySqlBindingPtr createInteger(T value) {
        MySqlBindingPtr binding(new MySqlBinding(MySqlBindingTraits<T>::column_type,
                                                 MySqlBindingTraits<T>::length));
        binding->setValue(value);
        return (binding);
    }
 
    template<typename T>
    static MySqlBindingPtr condCreateInteger(const util::Optional<T>& value) {
        return (value.unspecified() ? createNull() : createInteger<T>(value.get()));
    }
 
    static MySqlBindingPtr createFloat(const float value);
 
    template<typename T>
    static MySqlBindingPtr condCreateFloat(const util::Optional<T>& value) {
        return (value.unspecified() ? createNull() :
                createInteger<float> (static_cast<float>(value.get())));
    }
 
    static MySqlBindingPtr createBool();
 
    static MySqlBindingPtr createBool(const bool value);
 
    static MySqlBindingPtr condCreateBool(const util::Optional<bool>& value);
 
    static MySqlBindingPtr
    condCreateIPv4Address(const util::Optional<asiolink::IOAddress>& value);
 
    static MySqlBindingPtr createTimestamp();
 
    static MySqlBindingPtr createTimestamp(const boost::posix_time::ptime& timestamp);
 
    static MySqlBindingPtr createNull();
 
    static void convertToDatabaseTime(const time_t input_time,
                                      MYSQL_TIME& output_time);
 
    static void convertToDatabaseTime(const boost::posix_time::ptime& input_time,
                                      MYSQL_TIME& output_time);
 
    static void convertToDatabaseTime(const time_t cltt,
                                      const uint32_t valid_lifetime,
                                      MYSQL_TIME& expire);
 
    static void convertFromDatabaseTime(const MYSQL_TIME& expire,
                                        uint32_t valid_lifetime,
                                        time_t& cltt);
 
    static boost::posix_time::ptime
    convertFromDatabaseTime(const MYSQL_TIME& database_time);
 
private:
 
    MySqlBinding(enum_field_types buffer_type, const size_t length);
 
    template<typename Iterator>
    void setBufferValue(Iterator begin, Iterator end) {
        length_ = std::distance(begin, end);
        buffer_.assign(begin, end);
        // It appears that the MySQL connectors sometimes require that the
        // buffer is specified (set to a non-zero value), even if the buffer
        // length is 0. We have found that setting the buffer to 0 value would
        // cause the value inserted to the database be NULL. In order to avoid
        // it, we simply make sure that the buffer length is at least 1 byte and
        // provide the pointer to this byte within the binding.
        if (buffer_.empty()) {
            buffer_.resize(1);
        }
        bind_.buffer = &buffer_[0];
        bind_.buffer_length = length_;
    }
 
    void setBufferLength(const unsigned long length);
 
    template<typename T>
    void setValue(T value) {
        memcpy(static_cast<void*>(&buffer_[0]), reinterpret_cast<char*>(&value),
               sizeof(value));
        bind_.buffer = &buffer_[0];
        bind_.is_unsigned = (MySqlBindingTraits<T>::am_unsigned ? MLM_TRUE : MLM_FALSE);
    }
 
    void setTimestampValue(const boost::posix_time::ptime& timestamp);
 
    template<typename T>
    void validateAccess() const {
        // Can't retrieve null value.
        if (amNull()) {
            isc_throw(InvalidOperation, "retrieved value is null");
        }
        // The type of the accessor must match the stored data type.
        if (MySqlBindingTraits<T>::column_type != getType()) {
            isc_throw(InvalidOperation, "mismatched column type");
        }
    }
 
    std::vector<uint8_t> buffer_;
 
    unsigned long length_;
 
    my_bool null_value_;
 
    MYSQL_BIND bind_;
};
 
typedef std::vector<MySqlBindingPtr> MySqlBindingCollection;
 
 
} // end of namespace isc::db
} // end of namespace isc
 
#endif