dbValue.h

Go to the documentation of this file.

 
// Copyright (c) 2013-2015 OpenM++
// This code is licensed under the MIT license (see LICENSE.txt for details)
 
#ifndef DB_VALUE_H
#define DB_VALUE_H
 
#include "libopenm/db/dbCommon.h"
#include "helper.h"
#include "md5.h"
 
using namespace std;
 
namespace openm
{
    class DbValueSetter
    {
    public:
        DbValueSetter(const type_info & i_type);
 
        void set(const void * i_value, DbValue & o_dbVal);
 
        const type_info & valueType(void) const { return typeOf; };
 
    private:
        const type_info & typeOf;
 
        function<void(const void * i_value, DbValue & o_dbVal)> doSetValue;
 
        template<typename TValue> static void setValue(const void * i_value, DbValue & o_dbVal)
        {
            TValue val = *static_cast<const TValue *>(i_value);
            o_dbVal = DbValue(val);
        }
 
    private:
        // DbValueSetter(const DbValueSetter &) = delete;
        DbValueSetter & operator=(const DbValueSetter &) = delete;
    };
 
    template<typename TValue>
    int FormatHandler(const void * i_value, size_t i_size, char * io_buffer, const char * i_format)
    {
        TValue val = *static_cast<const TValue *>(i_value);
        return snprintf(io_buffer, i_size, i_format, val);
    }
 
    template<typename TValue>
    int FloatSqlFormatHandler(const void * i_value, size_t i_size, char * io_buffer, const char * i_format)
    {
        TValue val = *static_cast<const TValue *>(i_value);
 
        if (isfinite(val)) {
            return snprintf(io_buffer, i_size, i_format, val);
        }
        // else copy "NULL" into output buffer
        strncpy(io_buffer, "NULL", i_size);
        io_buffer[i_size - 1] = '\0';
        return (int)strnlen(io_buffer, i_size);
    }
 
    extern int BoolFormatHandler(const void * i_value, size_t i_size, char * io_buffer);
 
    extern int BoolSqlFormatHandler(const void * i_value, size_t i_size, char * io_buffer);
 
    extern int StrFormatHandler(const void * i_value, size_t i_size, char * io_buffer);
 
    extern int StrSqlFormatHandler(const void * i_value, size_t i_size, char * io_buffer);
 
    inline const char * nullValueString = "null";      
    inline const char * trueValueString = "true";      
    inline const char * falseValueString = "false";    
    template<const size_t valueLen>
    class ValueFormatterBase : public IValueFormatter
    {
    public:
        ValueFormatterBase(const type_info & i_type, bool i_isSqlFormat = false, const char * i_doubleFormat = "") :
            typeOf(i_type),
            doFormatValue(nullptr)
        {
            if (typeOf == typeid(char)) {
                doFormatValue = bind(FormatHandler<char>, placeholders::_1, placeholders::_2, placeholders::_3, "%hhd");
            }
            if (typeOf == typeid(unsigned char)) {
                doFormatValue = bind(FormatHandler<unsigned char>, placeholders::_1, placeholders::_2, placeholders::_3, "%hhu");
            }
            if (typeOf == typeid(short)) {
                doFormatValue = bind(FormatHandler<short>, placeholders::_1, placeholders::_2, placeholders::_3, "%hd");
            }
            if (typeOf == typeid(unsigned short)) {
                doFormatValue = bind(FormatHandler<unsigned short>, placeholders::_1, placeholders::_2, placeholders::_3, "%hu");
            }
            if (typeOf == typeid(int)) {
                doFormatValue = bind(FormatHandler<int>, placeholders::_1, placeholders::_2, placeholders::_3, "%d");
            }
            if (typeOf == typeid(unsigned int)) {
                doFormatValue = bind(FormatHandler<unsigned int>, placeholders::_1, placeholders::_2, placeholders::_3, "%u");
            }
            if (typeOf == typeid(long)) {
                doFormatValue = bind(FormatHandler<long>, placeholders::_1, placeholders::_2, placeholders::_3, "%ld");
            }
            if (typeOf == typeid(unsigned long)) {
                doFormatValue = bind(FormatHandler<unsigned long>, placeholders::_1, placeholders::_2, placeholders::_3, "%lu");
            }
            if (typeOf == typeid(long long)) {
                doFormatValue = bind(FormatHandler<long long>, placeholders::_1, placeholders::_2, placeholders::_3, "%lld");
            }
            if (typeOf == typeid(unsigned long long)) {
                doFormatValue = bind(FormatHandler<unsigned long long>, placeholders::_1, placeholders::_2, placeholders::_3, "%llu");
            }
            if (typeOf == typeid(int8_t)) {
                doFormatValue = bind(FormatHandler<int8_t>, placeholders::_1, placeholders::_2, placeholders::_3, "%hhd");
            }
            if (typeOf == typeid(uint8_t)) {
                doFormatValue = bind(FormatHandler<uint8_t>, placeholders::_1, placeholders::_2, placeholders::_3, "%hhu");
            }
            if (typeOf == typeid(int16_t)) {
                doFormatValue = bind(FormatHandler<int16_t>, placeholders::_1, placeholders::_2, placeholders::_3, "%hd");
            }
            if (typeOf == typeid(uint16_t)) {
                doFormatValue = bind(FormatHandler<uint16_t>, placeholders::_1, placeholders::_2, placeholders::_3, "%hu");
            }
            if (typeOf == typeid(int32_t)) {
                doFormatValue = bind(FormatHandler<int32_t>, placeholders::_1, placeholders::_2, placeholders::_3, "%d");
            }
            if (typeOf == typeid(uint32_t)) {
                doFormatValue = bind(FormatHandler<uint32_t>, placeholders::_1, placeholders::_2, placeholders::_3, "%u");
            }
            if (typeOf == typeid(int64_t)) {
                doFormatValue = bind(FormatHandler<int64_t>, placeholders::_1, placeholders::_2, placeholders::_3, "%lld");
            }
            if (typeOf == typeid(uint64_t)) {
                doFormatValue = bind(FormatHandler<uint64_t>, placeholders::_1, placeholders::_2, placeholders::_3, "%llu");
            }
 
            if (!i_isSqlFormat) {   // not a SQL constant: simple snprintf formatted values
 
                if (typeOf == typeid(bool)) {
                    doFormatValue = BoolFormatHandler;
                }
                if (typeOf == typeid(float)) {
                    doFormatValue = bind(
                        FormatHandler<float>,
                        placeholders::_1, placeholders::_2, placeholders::_3,
                        ((i_doubleFormat != nullptr && i_doubleFormat[0] != '\0') ? i_doubleFormat : "%.15g")
                    );
                }
                if (typeOf == typeid(double)) {
                    doFormatValue = bind(
                        FormatHandler<double>,
                        placeholders::_1, placeholders::_2, placeholders::_3,
                        ((i_doubleFormat != nullptr && i_doubleFormat[0] != '\0') ? i_doubleFormat : "%.15g")
                    );
                }
                if (typeOf == typeid(long double)) {
                    doFormatValue = bind(
                        FormatHandler<long double>,
                        placeholders::_1, placeholders::_2, placeholders::_3,
                        ((i_doubleFormat != nullptr && i_doubleFormat[0] != '\0') ? i_doubleFormat : "%.15g")
                    );
                }
                if (typeOf == typeid(string)) {
                    doFormatValue = StrFormatHandler;
                }
            }
            else {      // SQL constant: 'quoted strings', '1' or '0' for booleans, NULL if floats are not finite
 
                if (typeOf == typeid(bool)) {
                    doFormatValue = BoolSqlFormatHandler;
                }
                if (typeOf == typeid(float)) {
                    doFormatValue = bind(
                        FloatSqlFormatHandler<float>,
                        placeholders::_1, placeholders::_2, placeholders::_3,
                        ((i_doubleFormat != nullptr && i_doubleFormat[0] != '\0') ? i_doubleFormat : "%.15g")
                    );
                }
                if (typeOf == typeid(double)) {
                    doFormatValue = bind(
                        FloatSqlFormatHandler<double>,
                        placeholders::_1, placeholders::_2, placeholders::_3,
                        ((i_doubleFormat != nullptr && i_doubleFormat[0] != '\0') ? i_doubleFormat : "%.15g")
                    );
                }
                if (typeOf == typeid(long double)) {
                    doFormatValue = bind(
                        FloatSqlFormatHandler<long double>,
                        placeholders::_1, placeholders::_2, placeholders::_3,
                        ((i_doubleFormat != nullptr && i_doubleFormat[0] != '\0') ? i_doubleFormat : "%.15g")
                    );
                }
                if (typeOf == typeid(string)) {
                    doFormatValue = StrSqlFormatHandler;
                }
            }
 
            if (doFormatValue == nullptr)
                throw DbException("invalid value type to convert to string");  // conversion to target type is not supported
        }
 
        ValueFormatterBase(const type_info & i_type, const char * i_doubleFormat = "") :
            ValueFormatterBase(i_type, false, i_doubleFormat) {}
 
        const char * formatValue(const void * i_value, bool i_isNull = false) override
        {
            if (i_isNull || i_value == nullptr) return nullValueString;
 
            doFormatValue(i_value, valueLen, valueStr);
            return valueStr;
        }
 
    private:
        const type_info & typeOf;
 
        char valueStr[valueLen + 1] = "";
 
        // value to string converter handler
        function<int(const void * i_value, size_t i_size, char * io_buffer)> doFormatValue;
 
    private:
        ValueFormatterBase(const ValueFormatterBase &) = delete;
        ValueFormatterBase & operator=(const ValueFormatterBase &) = delete;
    };
 
    typedef ValueFormatterBase<OM_STR_DB_MAX> ValueFormatter;   
    typedef ValueFormatterBase<OM_CODE_DB_MAX> ShortFormatter;  
    struct ValueArray
    {
    public:
        ValueArray(const type_info & i_type, size_t i_size);
 
        ~ValueArray(void) noexcept { try { cleanup(); } catch (...) {} }
 
        void cleanup(void) noexcept;
 
        const type_info & typeOf(void) const { return valueType; }
 
        const size_t sizeOf(void) const { return valueCount; }
 
        void * ptr(void) const { return valueArr; }
 
    private:
        const type_info & valueType;    // value type
        const size_t valueCount;        // size of array: number of values
        void * valueArr;                // array data
 
        // create new array of primitive values and fill it with NaN
        template<typename TVal> TVal * newValueArray(size_t i_size)
        {
            TVal * pData = new TVal[i_size];
            fill(static_cast<TVal *>(pData), &(static_cast<TVal *>(pData))[i_size], numeric_limits<TVal>::quiet_NaN());
            return pData;
        }
 
    private:
        ValueArray(const ValueArray & i_src) = delete;
        ValueArray & operator=(const ValueArray & i_src) = delete;
    };
 
    struct ValueRow : public IRowBase
    {
        int idCount;
 
        unique_ptr<int32_t[]> idArr;
 
        bool isNotNull;
 
        const type_info & typeOf;
 
        DbValue dbVal;
 
        string strVal;
 
        ValueRow(int i_idCount, const type_info & i_type);
        ~ValueRow(void) noexcept { }
    };
 
    class ValueRowAdapter : public IRowAdapter
    {
    public:
        ValueRowAdapter(int i_idCount, const type_info & i_type);
 
        // IRowAdapter interface implementation
        IRowBase * createRow(void) const override { return new ValueRow(idCount, typeOf); }
        int size(void) const override { return idCount + 1; }
        const type_info * const * columnTypes(void) const override { return typeVec.data(); }
 
        void set(IRowBase * i_row, int i_column, const void * i_value) const override;
 
    private:
        int idCount;
 
        const type_info & typeOf;
 
        vector<const type_info *> typeVec;  // column types
 
        // set value column method handler
        function<void(const void * i_value, DbValue & o_dbVal)> doSetValue;
 
        // value column setter casting for numeric and boolean types
        template<typename TValue> static void setValueColumn(const void * i_value, DbValue & o_dbVal)
        {
            TValue val = *static_cast<const TValue *>(i_value);
            o_dbVal = DbValue(val);
        }
 
    private:
        ValueRowAdapter(const ValueRowAdapter &) = delete;
        ValueRowAdapter & operator=(const ValueRowAdapter &) = delete;
    };
 
    class ValueRowDigester : public IRowProcessor
    {
    public:
        ValueRowDigester(int i_idCount, const type_info & i_type, MD5 * io_md5, const char * i_doubleFormat = "");
 
        void processRow(IRowBaseUptr & i_row) override;
 
    private:
        int idCount;
 
        const type_info & typeOf;
 
        MD5 * md5;
 
        unique_ptr<IValueFormatter> fmtValue;
 
    private:
        ValueRowDigester(const ValueRowDigester &) = delete;
        ValueRowDigester & operator=(const ValueRowDigester &) = delete;
    };
}
 
#endif  // DB_VALUE_H