Data.hpp

Go to the documentation of this file.

/*
 *
 * ---
 *
 *  Copyright (C) 2022 Anselm Schmidt (ans[ät]ohai.su)
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version in addition to the terms of any
 *  licences already herein identified.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * ---
 *
 * Data.hpp
 *
 * Custom data structures for database access by algorithms.
 *
 *  Created on: Jan 16, 2019
 *      Author: ans
 */

#ifndef DATA_DATA_HPP_
#define DATA_DATA_HPP_

#include <algorithm>    // std::transform
#include <array>        // std::array
#include <cctype>       // std::tolower
#include <cstddef>      // std::size_t
#include <cstdint>      // std::int32_t, std::int64_t, std::uint32_t, std::uint64_t
#include <string>       // std::string
#include <tuple>        // std::tuple
#include <utility>      // std::pair, std::swap
#include <vector>       // std::vector

namespace crawlservpp::Data {

    /*
     * CONSTANTS
     */


    inline constexpr auto bytes32bit{4};

    inline constexpr auto bytes64bit{8};


    /*
     * DECLARATIONS
     */

    enum Type {
        _unknown,

        _bool,

        _int32,

        _uint32,

        _int64,

        _uint64,

        _double,

        _string
    };


    struct Value { //NOLINT(cppcoreguidelines-pro-type-member-init, hicpp-member-init)
        union {
            bool _b;

            std::int32_t _i32;

            std::uint32_t _ui32;

            std::int64_t _i64;

            std::uint64_t _ui64{};

            double _d;
        };

        std::string _s;

        bool _isnull{true};

        enum _if_too_large {
            _error,

            _trim,

            _empty,

            _null

        }


        _overflow{_if_too_large::_error};

        //NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init, hicpp-member-init)
        Value() = default;


        //NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init, hicpp-member-init)
        explicit Value(bool value) : _b(value), _isnull(false) {}


        //NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init, hicpp-member-init)
        explicit Value(std::int32_t value) : _i32(value), _isnull(false) {}


        //NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init, hicpp-member-init)
        explicit Value(std::uint32_t value) : _ui32(value), _isnull(false) {}


        //NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init, hicpp-member-init)
        explicit Value(std::int64_t value) : _i64(value), _isnull(false) {}


        //NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init, hicpp-member-init)
        explicit Value(std::uint64_t value) : _ui64(value), _isnull(false) {}


        //NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init, hicpp-member-init)
        explicit Value(double value) : _d(value), _isnull(false) {}


        //NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init, hicpp-member-init)
        explicit Value(const std::string& value) : _s(value), _isnull(false) {}

        void clear() {
            *this = Value();
        }
    };

    struct GetValue {
        std::string table;

        std::string column;

        Type type{_unknown};

        std::string condition;

        Value value;
    };

    struct GetFields {
        std::string table;

        std::vector<std::string> columns;

        Type type{_unknown};

        std::string condition;

        std::vector<Value> values;
    };

    struct GetFieldsMixed {
        std::string table;

        std::vector<std::pair<std::string, Type>> columns_types;

        std::string condition;

        std::vector<Value> values;
    };

    struct GetColumn {
        std::string table;

        std::string column;

        Type type{_unknown};

        std::string condition;


        std::vector<std::string> order;

        std::vector<Value> values;
    };

    struct GetColumns {
        std::string table;

        std::vector<std::string> columns;

        Type type{_unknown};

        std::string condition;


        std::vector<std::string> order;

        std::vector<std::vector<Value>> values;
    };

    struct GetColumnsMixed {
        std::string table;

        std::vector<std::pair<std::string, Type>> columns_types;

        std::string condition;


        std::vector<std::string> order;

        std::vector<std::vector<Value>> values;
    };

    struct InsertValue {
        std::string table;

        std::string column;

        Type type{_unknown};

        Value value;
    };

    struct InsertFields {
        std::string table;

        std::vector<std::pair<std::string, Value>> columns_values;

        Type type{_unknown};
    };

    struct InsertFieldsMixed {
        std::string table;

        std::vector<std::tuple<std::string, Type, Value>> columns_types_values;
    };

    struct UpdateValue {
        std::string table;

        std::string column;

        Type type{_unknown};


        Value value;

        std::string condition;
    };

    struct UpdateFields {
        std::string table;


        std::vector<std::pair<std::string, Value>> columns_values;

        Type type{_unknown};

        std::string condition;
    };

    struct UpdateFieldsMixed {
        std::string table;


        std::vector<std::tuple<std::string, Type, Value>> columns_types_values;

        std::string condition;
    };

    /*
     * HELPER FUNCTION
     */



    [[nodiscard]] inline Type parseSQLType(std::string sqlType) {
        // constants classifying SQL types
        constexpr std::array boolTypes{"bool", "boolean"};
        constexpr std::array int32Types{"bit", "tinyint", "smallint", "mediumint", "int", "integer"};
        constexpr std::array int64Types{"bigint"};
        constexpr std::array doubleTypes{"float", "double", "double precision", "decimal", "dec"};
        constexpr std::array stringTypes{
            "char",
            "varchar",
            "binary",
            "varbinary",
            "tinyblob",
            "tinytext",
            "text",
            "blob",
            "mediumtext",
            "longtext",
            "longblob",
            "enum",
            "set"
        };

        // convert data type to lower case
        std::transform(
                sqlType.begin(),
                sqlType.end(),
                sqlType.begin(),
                [](const auto c) {
                    return std::tolower(c);
                }
        );

        // remove size from retrieved data type
        const auto bracketPos{sqlType.find_first_of('(')};

        if(bracketPos != std::string::npos) {
            const auto bracketEnd{sqlType.find_first_of(')', bracketPos + 1)};

            if(bracketEnd != std::string::npos) {
                sqlType = sqlType.substr(0, bracketPos) + sqlType.substr(bracketEnd + 1);
            }
        }

        // detect types (unsigned ones first)
        for(const auto& type : boolTypes) {
            const std::string typeString{type};

            if(sqlType.substr(0, typeString.length()) == typeString) {
                return Type::_bool;
            }
        }

        for(const auto& type : int32Types) {
            const std::string typeString{type};
            const auto unsignedType{typeString + " unsigned"};

            if(sqlType.substr(0, unsignedType.length()) == unsignedType) {
                return Type::_uint32;
            }

            if(sqlType.substr(0, typeString.length()) == typeString) {
                return Type::_int32;
            }
        }

        for(const auto& type : int64Types) {
            const std::string typeString{type};
            const auto unsignedType{typeString + " unsigned"};

            if(sqlType.substr(0, unsignedType.length()) == unsignedType) {
                return Type::_uint64;
            }

            if(sqlType.substr(0, typeString.length()) == typeString) {
                return Type::_int64;
            }
        }

        for(const auto& type : doubleTypes) {
            const std::string typeString{type};

            if(sqlType.substr(0, typeString.length()) == typeString) {
                return Type::_double;
            }
        }

        for(const auto& type : stringTypes) {
            const std::string typeString{type};

            if(sqlType.substr(0, typeString.length()) == typeString) {
                return Type::_string;
            }
        }

        return Type::_unknown;
    }


    /*
     * TEMPLATE FUNCTIONS
     */


    template<int> Type getTypeOfSizeT();

    template<> inline Type getTypeOfSizeT<bytes32bit>() {
        return Type::_uint32;
    }

    template<> inline Type getTypeOfSizeT<bytes64bit>() {
        return Type::_uint64;
    }

    inline Type getTypeOfSizeT() {
        return getTypeOfSizeT<sizeof(std::size_t)>();
    }


} /* namespace crawlservpp::Data */

#endif /* DATA_DATA_HPP_ */