prepared_statement.hxx

#ifndef PQXX_H_PREPARED_STATEMENT
#define PQXX_H_PREPARED_STATEMENT

#include "pqxx/compiler-public.hxx"
#include "pqxx/compiler-internal-pre.hxx"

#include "pqxx/types.hxx"
#include "pqxx/internal/statement_parameters.hxx"



namespace pqxx
{
namespace prepare
{

template<typename IT> inline pqxx::internal::dynamic_params<IT>
make_dynamic_params(IT begin, IT end)
{
  return pqxx::internal::dynamic_params<IT>(begin, end);
}



template<typename C>
inline pqxx::internal::dynamic_params<typename C::const_iterator>
make_dynamic_params(const C &container)
{
  return pqxx::internal::dynamic_params<typename C::const_iterator>(container);
}
} // namespace prepare
} // namespace pqxx

namespace pqxx
{
namespace prepare
{

class PQXX_LIBEXPORT invocation : internal::statement_parameters
{
public:
  PQXX_DEPRECATED invocation(transaction_base &, const std::string &statement);
  invocation &operator=(const invocation &) =delete;

  result exec() const;

  bool exists() const;

  invocation &operator()() { add_param(); return *this; }


  template<typename T> invocation &operator()(const T &v)
        { add_param(v, true); return *this; }


  invocation &operator()(const binarystring &v)
        { add_binary_param(v, true); return *this; }


  template<typename T> invocation &operator()(const T &v, bool nonnull)
        { add_param(v, nonnull); return *this; }


  invocation &operator()(const binarystring &v, bool nonnull)
        { add_binary_param(v, nonnull); return *this; }


  template<typename T> invocation &operator()(T *v, bool nonnull=true)
        { add_param(v, nonnull); return *this; }


  invocation &operator()(const char *v, bool nonnull=true)
        { add_param(v, nonnull); return *this; }

private:
  transaction_base &m_home;
  const std::string m_statement;

  invocation &setparam(const std::string &, bool nonnull);
};


namespace internal
{
struct PQXX_LIBEXPORT prepared_def
{
  std::string definition;
  bool registered = false;

  prepared_def() =default;
  explicit prepared_def(const std::string &);
};

} // namespace pqxx::prepare::internal
} // namespace pqxx::prepare
} // namespace pqxx

#include "pqxx/compiler-internal-post.hxx"
#endif