function.hpp

//
// Copyright (c) 2022 Klemens Morgenstern (klemens.morgenstern@gmx.net)
//
// 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_FUNCTION_HPP
#define BOOST_SQLITE_FUNCTION_HPP
 
#include <boost/sqlite/detail/config.hpp>
#include <boost/sqlite/detail/aggregate_function.hpp>
#include <boost/sqlite/detail/scalar_function.hpp>
#include <boost/sqlite/detail/window_function.hpp>
#include <boost/sqlite/connection.hpp>
#include <boost/sqlite/result.hpp>
#include <boost/sqlite/value.hpp>
#include <boost/sqlite/detail/exception.hpp>
#include <boost/sqlite/cstring_ref.hpp>
 
#include <boost/core/span.hpp>
#include <boost/callable_traits/args.hpp>
#include <boost/callable_traits/has_void_return.hpp>
#include <boost/callable_traits/return_type.hpp>
 
BOOST_SQLITE_BEGIN_NAMESPACE
 
 
template<typename ... Args>
struct context
{
  template<std::size_t N>
  using element = mp11::mp_take_c<mp11::mp_list<Args...>, N>;
 
  template<std::size_t Idx>
  void set(element<Idx> value)
  {
    sqlite3_set_auxdata(ctx_, Idx, *static_cast<void**>(&value),
                        new (memory_tag{}) element<Idx>(std::move(value)),
                        +[](void * ptr)
                        {
                          delete_(static_cast<element<Idx> *>(ptr));
                        });
  }
 
  template<std::size_t Idx>
  auto get() -> element<Idx>  &
  {
    using type = element<Idx> ;
    auto p = static_cast<type*>(sqlite3_get_auxdata(ctx_, Idx));
    if (p == nullptr)
      detail::throw_invalid_argument("argument not set",
                                     BOOST_CURRENT_LOCATION);
    return *p;
  }
 
  template<std::size_t Idx>
  auto get_if() -> element<Idx>  *
  {
    using type = element<Idx> ;
    return static_cast<type*>(sqlite3_get_auxdata(ctx_, Idx));
  }
 
 
  explicit context(sqlite3_context * ctx) noexcept : ctx_(ctx) {}
 
  template<typename T>
  auto set_result(T && val)
#if !defined(BOOST_SQLITE_GENERATING_DOCS)
    -> decltype(detail::set_result(static_cast<sqlite3_context*>(nullptr), std::forward<T>(val)))
#endif
  {
    detail::set_result(ctx_, std::forward<T>(val));
  }
  void set_error(cstring_ref message, int code = SQLITE_ERROR)
  {
    sqlite3_result_error(ctx_, message.c_str(), code);
  }
  connection get_connection() const
  {
    return connection{sqlite3_context_db_handle(ctx_), false};
  }
 
 private:
  sqlite3_context * ctx_;
};
 
 
 
template<typename Func>
auto create_scalar_function(
    connection & conn,
    cstring_ref name,
    Func && func,
    system::error_code & ec)
#if !defined(BOOST_SQLITE_GENERATING_DOCS)
    -> typename std::enable_if<
        std::is_same<
          decltype(
              detail::create_scalar_function(
                  static_cast<sqlite3*>(nullptr), name,
                  std::declval<Func>())
              ), int>::value>::type
#endif
{
    auto res = detail::create_scalar_function(conn.handle(), name, std::forward<Func>(func));
    if (res != 0)
        BOOST_SQLITE_ASSIGN_EC(ec, res);
}
 
 
template<typename Func>
auto create_scalar_function(
    connection & conn,
    cstring_ref name,
    Func && func)
    -> typename std::enable_if<
        std::is_same<
          decltype(
              detail::create_scalar_function(
                  static_cast<sqlite3*>(nullptr), name,
                  std::declval<Func>())
              ), int>::value>::type
{
    system::error_code ec;
    create_scalar_function(conn, name, std::forward<Func>(func), ec);
    if (ec)
        detail::throw_error_code(ec,
                        BOOST_CURRENT_LOCATION);
}
 
 
 
template<typename Func>
void create_aggregate_function(
    connection & conn,
    cstring_ref name,
    Func && func,
    system::error_code & ec,
    error_info & ei)
{
    using func_type = typename std::decay<Func>::type;
    auto res = detail::create_aggregate_function(
        conn.handle(), name, std::forward<Func>(func),
        callable_traits::has_void_return<decltype(&func_type::step)>{}
        );
    if (res != 0)
    {
        BOOST_SQLITE_ASSIGN_EC(ec, res);
        ei.set_message(sqlite3_errmsg(conn.handle()));
    }
}
 
template<typename Func>
void create_aggregate_function(
    connection & conn,
    cstring_ref name,
    Func && func)
{
    system::error_code ec;
    error_info ei;
    create_aggregate_function(conn, name, std::forward<Func>(func), ec, ei);
    if (ec)
        detail::throw_error_code(ec, ei);
}
 
#if SQLITE_VERSION_NUMBER >= 3025000
 
 
template<typename Func>
void create_window_function(
    connection & conn,
    cstring_ref name,
    Func && func,
    system::error_code & ec)
{
    using func_type = typename std::decay<Func>::type;
    auto res = detail::create_window_function(
            conn.handle(), name, std::forward<Func>(func),
            callable_traits::has_void_return<decltype(&func_type::step)>{});
    if (res != 0)
        BOOST_SQLITE_ASSIGN_EC(ec, res);
}
 
template<typename Func>
void create_window_function(
    connection & conn,
    cstring_ref name,
    Func && func)
{
    system::error_code ec;
    create_window_function(conn, name, std::forward<Func>(func), ec);
    if (ec)
        detail::throw_error_code(ec);
}
 
 
#endif
 
BOOST_SQLITE_END_NAMESPACE
 
#endif //BOOST_SQLITE_FUNCTION_HPP