pipeline.hxx

#ifndef PQXX_H_PIPELINE
#define PQXX_H_PIPELINE

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

#include <limits>
#include <map>
#include <string>

#include "pqxx/transaction_base.hxx"


// Methods tested in eg. test module test01 are marked with "//[t01]".

namespace pqxx
{


class PQXX_LIBEXPORT pipeline : public internal::transactionfocus
{
public:
  using query_id = long;

  pipeline(const pipeline &) =delete;
  pipeline &operator=(const pipeline &) =delete;

  explicit pipeline(                                                    //[t69]
        transaction_base &,
        const std::string &Name=std::string());

  ~pipeline() noexcept;


  query_id insert(const std::string &);                                 //[t69]


  void complete();                                                      //[t71]


  void flush();                                                         //[t70]


  void cancel();

  bool is_finished(query_id) const;                                     //[t71]


  result retrieve(query_id qid)                                         //[t71]
        { return retrieve(m_queries.find(qid)).second; }


  std::pair<query_id, result> retrieve();                               //[t69]

  bool empty() const noexcept { return m_queries.empty(); }             //[t69]


  int retain(int retain_max=2);                                         //[t70]


  void resume();                                                        //[t70]

private:
  class PQXX_PRIVATE Query
  {
  public:
    explicit Query(const std::string &q) : m_query(q), m_res() {}

    const result &get_result() const noexcept { return m_res; }
    void set_result(const result &r) noexcept { m_res = r; }
    const std::string &get_query() const noexcept { return m_query; }

  private:
    std::string m_query;
    result m_res;
  };

  using QueryMap = std::map<query_id,Query>;

  struct getquery
  {
    getquery(){}        // Silences bogus warning in some gcc versions
    std::string operator()(QueryMap::const_iterator i) const
        { return i->second.get_query(); }
  };

  void attach();
  void detach();

  static constexpr query_id qid_limit() noexcept
  {
    // Parenthesise this to work around an eternal Visual C++ problem:
    // Without the extra parentheses, unless NOMINMAX is defined, the
    // preprocessor will mistake this "max" for its annoying built-in macro
    // of the same name.
    return (std::numeric_limits<query_id>::max)();
  }

  PQXX_PRIVATE query_id generate_id();

  bool have_pending() const noexcept
        { return m_issuedrange.second != m_issuedrange.first; }

  PQXX_PRIVATE void issue();

  void set_error_at(query_id qid) noexcept
        { if (qid < m_error) m_error = qid; }

  [[noreturn]] PQXX_PRIVATE void internal_error(const std::string &err);

  PQXX_PRIVATE bool obtain_result(bool expect_none=false);

  PQXX_PRIVATE void obtain_dummy();
  PQXX_PRIVATE void get_further_available_results();
  PQXX_PRIVATE void check_end_results();

  PQXX_PRIVATE void receive_if_available();

  PQXX_PRIVATE void receive(pipeline::QueryMap::const_iterator stop);
  std::pair<pipeline::query_id, result>
    retrieve(pipeline::QueryMap::iterator);

  QueryMap m_queries;
  std::pair<QueryMap::iterator,QueryMap::iterator> m_issuedrange;
  int m_retain = 0;
  int m_num_waiting = 0;
  query_id m_q_id = 0;

  bool m_dummy_pending = false;

  query_id m_error = qid_limit();
};

} // namespace

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

#endif