connection.hxx

/* Definition of the connection class.
 *
 * pqxx::connection encapsulates a connection to a database.
 *
 * DO NOT INCLUDE THIS FILE DIRECTLY; include pqxx/connection instead.
 *
 * Copyright (c) 2000-2020, Jeroen T. Vermeulen.
 *
 * See COPYING for copyright license.  If you did not receive a file called
 * COPYING with this source code, please notify the distributor of this
 * mistake, or contact the author.
 */
#ifndef PQXX_H_CONNECTION
#define PQXX_H_CONNECTION

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

#include <cstddef>
#include <ctime>
#include <functional>
#include <list>
#include <map>
#include <memory>
#include <string_view>
#include <tuple>

#if __has_include(<ranges>)
#  include <ranges>
#endif

#include "pqxx/errorhandler.hxx"
#include "pqxx/except.hxx"
#include "pqxx/prepared_statement.hxx"
#include "pqxx/strconv.hxx"
#include "pqxx/util.hxx"
#include "pqxx/zview.hxx"


namespace pqxx::internal
{
class sql_cursor;

#if defined(PQXX_HAVE_CONCEPTS)
template<typename T>
concept ZKey_ZValues = std::ranges::input_range<T> and requires()
{
  {std::tuple_size<typename std::ranges::iterator_t<T>::value_type>::value};
}
and std::tuple_size_v<typename std::ranges::iterator_t<T>::value_type> == 2 and
  requires(T t)
{
  {
    std::get<0>(*std::cbegin(t))
  }
  ->ZString;
  {
    std::get<1>(*std::cbegin(t))
  }
  ->ZString;
};
#endif // PQXX_HAVE_CONCEPTS
} // namespace pqxx::internal


namespace pqxx::internal::gate
{
class connection_dbtransaction;
class connection_errorhandler;
class connection_largeobject;
class connection_notification_receiver;
class connection_pipeline;
class connection_sql_cursor;
class connection_stream_from;
class connection_stream_to;
class connection_transaction;
class const_connection_largeobject;
} // namespace pqxx::internal::gate


namespace pqxx
{
[[nodiscard]] std::string PQXX_LIBEXPORT
encrypt_password(char const user[], char const password[]);

[[nodiscard]] inline std::string encrypt_password(zview user, zview password)
{
  return encrypt_password(user.c_str(), password.c_str());
}


enum class error_verbosity : int
{
  // These values must match those in libpq's PGVerbosity enum.
  terse = 0,
  normal = 1,
  verbose = 2
};



class PQXX_LIBEXPORT connection
{
public:
  connection() : connection{""} {}

  explicit connection(char const options[])
  {
    check_version();
    init(options);
  }

  explicit connection(zview options) : connection{options.c_str()}
  {
    // (Delegates to other constructor which calls check_version for us.)
  }


  connection(connection &&rhs);

#if defined(PQXX_HAVE_CONCEPTS)

  template<internal::ZKey_ZValues MAPPING>
  inline connection(MAPPING const &params);
#endif // PQXX_HAVE_CONCEPTS

  ~connection()
  {
    try
    {
      close();
    }
    catch (std::exception const &)
    {}
  }


  connection &operator=(connection &&rhs);

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


  [[nodiscard]] bool PQXX_PURE is_open() const noexcept;

  void process_notice(char const[]) noexcept;

  void process_notice(zview) noexcept;

  void trace(std::FILE *) noexcept;

  [[nodiscard]] char const *dbname() const;

  [[nodiscard]] char const *username() const;

  [[nodiscard]] char const *hostname() const;

  [[nodiscard]] char const *port() const;

  [[nodiscard]] int PQXX_PURE backendpid() const noexcept;


  [[nodiscard]] int PQXX_PURE sock() const noexcept;


  [[nodiscard]] int PQXX_PURE protocol_version() const noexcept;


  [[nodiscard]] int PQXX_PURE server_version() const noexcept;


  [[nodiscard]] std::string get_client_encoding() const;


  void set_client_encoding(zview encoding)
  {
    set_client_encoding(encoding.c_str());
  }


  void set_client_encoding(char const encoding[]);

  [[nodiscard]] int PQXX_PRIVATE encoding_id() const;



  void set_variable(std::string_view var, std::string_view value);


  std::string get_variable(std::string_view);



  int get_notifs();



  int await_notification();


  int await_notification(std::time_t seconds, long microseconds);


  [[nodiscard]] std::string encrypt_password(
    char const user[], char const password[], char const *algorithm = nullptr);
  [[nodiscard]] std::string
  encrypt_password(zview user, zview password, zview algorithm)
  {
    return encrypt_password(user.c_str(), password.c_str(), algorithm.c_str());
  }


  void prepare(char const name[], char const definition[]);

  void prepare(zview name, zview definition)
  {
    prepare(name.c_str(), definition.c_str());
  }


  void prepare(char const definition[]);
  void prepare(zview definition) { return prepare(definition.c_str()); }

  void unprepare(std::string_view name);


  [[nodiscard]] std::string adorn_name(std::string_view);



  [[nodiscard]] std::string esc(char const text[], std::size_t maxlen) const
  {
    return esc(std::string_view(text, maxlen));
  }

  [[nodiscard]] std::string esc(char const text[]) const
  {
    return esc(std::string_view(text));
  }


  [[nodiscard]] std::string esc(std::string_view text) const;


  [[nodiscard]] std::string
  esc_raw(unsigned char const bin[], std::size_t len) const;

  [[nodiscard]] std::string esc_raw(std::basic_string_view<std::byte>) const;


  [[nodiscard]] std::string unesc_raw(zview text) const
  {
    return unesc_raw(text.c_str());
  }


  [[nodiscard]] std::string unesc_raw(char const text[]) const;


  [[nodiscard]] std::string
  quote_raw(unsigned char const bin[], std::size_t len) const;

  [[nodiscard]] std::string quote_raw(std::basic_string_view<std::byte>) const;

  [[nodiscard]] std::string quote_name(std::string_view identifier) const;


  template<typename T>
  [[nodiscard]] inline std::string quote(T const &t) const;

  [[nodiscard]] std::string quote(binarystring const &) const;

  [[nodiscard]] std::string
  quote(std::basic_string_view<std::byte> bytes) const;


  [[nodiscard]] std::string
  esc_like(std::string_view text, char escape_char = '\\') const;


  void cancel_query();


  void set_verbosity(error_verbosity verbosity) noexcept;


  [[nodiscard]] std::vector<errorhandler *> get_errorhandlers() const;


  [[nodiscard]] std::string connection_string() const;


  void close();

private:
  // Initialise based on connection string.
  void init(char const options[]);
  // Initialise based on parameter names and values.
  void init(char const *params[], char const *values[]);
  void complete_init();

  void wait_read() const;
  void wait_read(std::time_t seconds, long microseconds) const;

  result make_result(
    internal::pq::PGresult *pgr, std::shared_ptr<std::string> const &query);

  void PQXX_PRIVATE set_up_state();

  int PQXX_PRIVATE PQXX_PURE status() const noexcept;


  std::size_t esc_to_buf(std::string_view text, char *buf) const;

  friend class internal::gate::const_connection_largeobject;
  char const *PQXX_PURE err_msg() const noexcept;

  void PQXX_PRIVATE process_notice_raw(char const msg[]) noexcept;

  result exec_prepared(std::string_view statement, internal::params const &);

  void check_movable() const;
  void check_overwritable() const;

  friend class internal::gate::connection_errorhandler;
  void PQXX_PRIVATE register_errorhandler(errorhandler *);
  void PQXX_PRIVATE unregister_errorhandler(errorhandler *) noexcept;

  friend class internal::gate::connection_transaction;
  result PQXX_PRIVATE exec(std::string_view);
  result PQXX_PRIVATE exec(std::shared_ptr<std::string>);
  void PQXX_PRIVATE register_transaction(transaction_base *);
  void PQXX_PRIVATE unregister_transaction(transaction_base *) noexcept;

  friend class internal::gate::connection_stream_from;
  std::pair<std::unique_ptr<char, std::function<void(char *)>>, std::size_t>
    PQXX_PRIVATE read_copy_line();

  friend class internal::gate::connection_stream_to;
  void PQXX_PRIVATE write_copy_line(std::string_view);
  void PQXX_PRIVATE end_copy_write();

  friend class internal::gate::connection_largeobject;
  internal::pq::PGconn *raw_connection() const { return m_conn; }

  friend class internal::gate::connection_notification_receiver;
  void add_receiver(notification_receiver *);
  void remove_receiver(notification_receiver *) noexcept;

  friend class internal::gate::connection_pipeline;
  void PQXX_PRIVATE start_exec(char const query[]);
  bool PQXX_PRIVATE consume_input() noexcept;
  bool PQXX_PRIVATE is_busy() const noexcept;
  internal::pq::PGresult *get_result();

  friend class internal::gate::connection_dbtransaction;
  friend class internal::gate::connection_sql_cursor;

  result exec_params(std::string_view query, internal::params const &args);

  internal::pq::PGconn *m_conn = nullptr;


  transaction_base const *m_trans = nullptr;

  std::list<errorhandler *> m_errorhandlers;

  using receiver_list =
    std::multimap<std::string, pqxx::notification_receiver *>;
  receiver_list m_receivers;

  int m_unique_id = 0;
};


using connection_base = connection;


template<typename T> inline std::string connection::quote(T const &t) const
{
  if constexpr (nullness<T>::always_null)
  {
    return "NULL";
  }
  else
  {
    if (is_null(t))
      return "NULL";
    auto const text{to_string(t)};

    // Okay, there's an easy way to do this and there's a hard way.  The easy
    // way was "quote, esc(to_string(t)), quote".  I'm going with the hard way
    // because it's going to save some string manipulation that will probably
    // incur some unnecessary memory allocations and deallocations.
    std::string buf{'\''};
    buf.resize(2 + 2 * std::size(text) + 1);
    auto const content_bytes{esc_to_buf(text, buf.data() + 1)};
    auto const closing_quote{1 + content_bytes};
    buf[closing_quote] = '\'';
    auto const end{closing_quote + 1};
    buf.resize(end);
    return buf;
  }
}


#if defined(PQXX_HAVE_CONCEPTS)
template<internal::ZKey_ZValues MAPPING>
inline connection::connection(MAPPING const &params)
{
  check_version();

  std::vector<char const *> keys, values;
  if constexpr (std::ranges::sized_range<MAPPING>)
  {
    auto const size{std::ranges::size(params) + 1};
    keys.reserve(size);
    values.reserve(size);
  }
  for (auto const &[key, value] : params)
  {
    keys.push_back(internal::as_c_string(key));
    values.push_back(internal::as_c_string(value));
  }
  keys.push_back(nullptr);
  values.push_back(nullptr);
  init(keys.data(), values.data());
}
#endif // PQXX_HAVE_CONCEPTS
} // namespace pqxx


namespace pqxx::internal
{
PQXX_LIBEXPORT void wait_read(internal::pq::PGconn const *);
PQXX_LIBEXPORT void wait_read(
  internal::pq::PGconn const *, std::time_t seconds, long microseconds);
PQXX_LIBEXPORT void wait_write(internal::pq::PGconn const *);
} // namespace pqxx::internal

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