value_iface.hpp

/*
 Copyright 2019 Eugene Gershnik
 
 Use of this source code is governed by a BSD-style
 license that can be found in the LICENSE file or at
 https://github.com/gershnik/thinsqlitepp/blob/master/LICENSE
*/
 
#ifndef HEADER_SQLITEPP_VALUE_IFACE_INCLUDED
#define HEADER_SQLITEPP_VALUE_IFACE_INCLUDED
 
#include "handle.hpp"
#include "span.hpp"
#include "exception_iface.hpp"
 
#include <memory>
#include <string_view>
 
namespace thinsqlitepp
{

    SQLITEPP_EXPORTED
    class value final : public handle<sqlite3_value, value>
    {
    public:
#if SQLITE_VERSION_NUMBER >= SQLITEPP_SQLITE_VERSION(3, 18, 0)
        static std::unique_ptr<value> dup(const value * src)
        {
            auto ret = sqlite3_value_dup(src ? src->c_ptr() : nullptr);
            if (!ret && src)
                throw exception(SQLITE_NOMEM);
            return std::unique_ptr<value>((value *)ret);
        }

        static std::unique_ptr<value> dup(const std::unique_ptr<value> & src) 
            { return dup(src.get()); }
        
        ~value() noexcept
            { sqlite3_value_free(c_ptr()); }
#endif
 
    private:
        template<typename T>
        static constexpr bool supported_column_type = 
            std::is_same_v<T, int> ||
            std::is_same_v<T, int64_t> ||
            std::is_same_v<T, double> ||
            std::is_same_v<T, std::string_view> ||
        #if __cpp_char8_t >= 201811
            std::is_same_v<T, std::u8string_view> ||
        #endif
            std::is_same_v<T, blob_view>;
 
    public:
        
        template<class T>
        SQLITEPP_ENABLE_IF(supported_column_type<T>,
        T) get() const noexcept;
 
    #if SQLITE_VERSION_NUMBER >= SQLITEPP_SQLITE_VERSION(3, 20, 0)

        template<class T>
        SQLITEPP_ENABLE_IF(std::is_pointer_v<T>,
        T) get(const char * type = nullptr) const noexcept 
            { return static_cast<T>(sqlite3_value_pointer(c_ptr(), type ? type : typeid(T).name())); }
 
 
    #endif
        
        int type() const noexcept
            { return sqlite3_value_type(c_ptr()); }
        
#if SQLITE_VERSION_NUMBER >= SQLITEPP_SQLITE_VERSION(3, 9, 0)
        unsigned subtype()const noexcept
            { return sqlite3_value_subtype(c_ptr()); }
#endif
        
        int numeric_type() const noexcept
            { return sqlite3_value_numeric_type(c_ptr()); }
        
#if SQLITE_VERSION_NUMBER >= SQLITEPP_SQLITE_VERSION(3, 22, 0)
        bool nochange() const noexcept
            { return sqlite3_value_nochange(c_ptr()); }
#endif
        
#if SQLITE_VERSION_NUMBER >= SQLITEPP_SQLITE_VERSION(3, 28, 0)
        bool frombind() const noexcept
            { return sqlite3_value_frombind(c_ptr()); }
#endif
 
#if SQLITE_VERSION_NUMBER >= SQLITEPP_SQLITE_VERSION(3, 38, 0)
        value * in_first() const 
        {
            sqlite3_value * ret;
            int res = sqlite3_vtab_in_first(c_ptr(), &ret);
            if (res != SQLITE_OK && res != SQLITE_DONE)
                throw exception(res);
            return from(ret);
        }

        value * in_next() const 
        {
            sqlite3_value * ret;
            int res = sqlite3_vtab_in_next(c_ptr(), &ret);
            if (res != SQLITE_OK && res != SQLITE_DONE)
                throw exception(res);
            return from(ret);
        }
#endif
    };


 
    template<>
    inline int value::get<int>() const noexcept
        { return sqlite3_value_int(c_ptr()); }
 
    template<>
    inline int64_t value::get<int64_t>() const noexcept
        { return sqlite3_value_int64(c_ptr()); }
 
    template<>
    inline std::string_view value::get<std::string_view>() const noexcept
    {
        auto first = (const char *)sqlite3_value_text(c_ptr());
        auto size = (size_t)sqlite3_value_bytes(c_ptr());
        return std::string_view(first, size);
    }
 
#if __cpp_char8_t >= 201811
    template<>
    inline std::u8string_view value::get<std::u8string_view>() const noexcept
    {
        auto first = (const char8_t *)sqlite3_value_text(c_ptr());
        auto size = (size_t)sqlite3_value_bytes(c_ptr());
        return std::u8string_view(first, size);
    }
#endif
 
    template<>
    inline double value::get<double>() const noexcept
        { return sqlite3_value_double(c_ptr()); }
 
    template<>
    inline blob_view value::get<blob_view>() const noexcept
    {
        auto first = (const std::byte *)sqlite3_value_blob(c_ptr());
        auto size = sqlite3_value_bytes(c_ptr());
        return blob_view(first, first + size);
    }

}
 
 
#endif