blob.hpp

// Copyright (c) 2022 Klemens D. Morgenstern
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_SQLITE_BLOB_HPP
#define BOOST_SQLITE_BLOB_HPP
 
#include <boost/sqlite/detail/config.hpp>
#include <boost/sqlite/memory.hpp>
#include <boost/sqlite/error.hpp>
#include <type_traits>
#include <memory>
#include <cstring>
 
BOOST_SQLITE_BEGIN_NAMESPACE
 
struct connection ;
 
struct blob_view
{
    const void * data() const {return data_;}
    std::size_t size() const {return size_;}
    blob_view(const void * data, std::size_t size) : data_(data), size_(size) {}
 
    template<typename T>
    explicit blob_view(const T & value,
                       typename std::enable_if<
                           std::is_pointer<decltype(std::declval<T>().data())>::value
                        && std::is_convertible<decltype(std::declval<T>().size()), std::size_t>::value
                           >::type * = nullptr) : data_(value.data()), size_(value.size()) {}
 
    inline blob_view(const struct blob & b);
  private:
    const void * data_{nullptr};
    std::size_t size_{0u};
};
 
enum class zero_blob : sqlite3_uint64 {};
 
struct blob
{
    void * data() const {return impl_.get();}
    std::size_t size() const {return size_;}
 
    explicit blob(blob_view bv)
    {
        impl_.reset(sqlite3_malloc(bv.size()));
        size_ = bv.size();
        std::memcpy(impl_.get(), bv.data(), size_);
    }
    explicit blob(std::size_t n) : impl_(sqlite3_malloc(n)), size_(n) {}
    void * release() && {return std::move(impl_).release(); }
   private:
    unique_ptr<void> impl_;
    std::size_t size_{0u};
};
 
blob_view::blob_view(const blob & b) : data_(b.data()), size_(b.size()) {}
 
struct blob_handle
{
    blob_handle() = default;
 
    explicit blob_handle(sqlite3_blob * blob) : blob_(blob) {}
 
    BOOST_SQLITE_DECL
    void reopen(sqlite3_int64 row_id, system::error_code & ec);
    BOOST_SQLITE_DECL
    void reopen(sqlite3_int64 row_id);
 
    BOOST_SQLITE_DECL
    void read_at(void *data, int len, int offset, system::error_code &ec);
    BOOST_SQLITE_DECL
    void read_at(void *data, int len, int offset);
 
    BOOST_SQLITE_DECL
    void write_at(const void *data, int len, int offset, system::error_code &ec);
    BOOST_SQLITE_DECL
    void write_at(const void *data, int len, int offset);
 
    std::size_t size() const {return static_cast<std::size_t>(sqlite3_blob_bytes(blob_.get()));}
 
    using handle_type = sqlite3_blob*;
    handle_type handle() { return blob_.get(); }
    handle_type release() &&    { return blob_.release(); }
 private:
    struct deleter_
    {
        void operator()(sqlite3_blob *impl)
        {
          sqlite3_blob_close(impl);
        }
    };
    std::unique_ptr<sqlite3_blob, deleter_> blob_;
};
 
BOOST_SQLITE_DECL
blob_handle open_blob(connection & conn,
                      cstring_ref db,
                      cstring_ref table,
                      cstring_ref column,
                      sqlite3_int64 row,
                      bool read_only,
                      system::error_code &ec,
                      error_info &ei);
 
BOOST_SQLITE_DECL
blob_handle open_blob(connection & conn,
                      cstring_ref db,
                      cstring_ref table,
                      cstring_ref column,
                      sqlite3_int64 row,
                      bool read_only = false);
 
 
 
BOOST_SQLITE_END_NAMESPACE
 
 
#endif //BOOST_SQLITE_BLOB_HPP