except.hxx

#ifndef PQXX_H_EXCEPT
#define PQXX_H_EXCEPT

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

#include <stdexcept>

#include "pqxx/util.hxx"


namespace pqxx
{


class PQXX_LIBEXPORT PQXX_NOVTABLE pqxx_exception
{
public:
  virtual ~pqxx_exception() noexcept =0;


  PQXX_CONST virtual const std::exception &base() const noexcept =0;    //[t00]
};


class PQXX_LIBEXPORT failure :
  public pqxx_exception, public std::runtime_error
{
  virtual const std::exception &base() const noexcept override
        { return *this; }
public:
  explicit failure(const std::string &);
};



class PQXX_LIBEXPORT broken_connection : public failure
{
public:
  broken_connection();
  explicit broken_connection(const std::string &);
};



class PQXX_LIBEXPORT sql_error : public failure
{
  const std::string m_query;
  const std::string m_sqlstate;

public:
  explicit sql_error(
        const std::string &msg="",
        const std::string &Q="",
        const char sqlstate[]=nullptr);
  virtual ~sql_error() noexcept;

  PQXX_PURE const std::string &query() const noexcept;                  //[t56]
  PQXX_PURE const std::string &sqlstate() const noexcept;
};



class PQXX_LIBEXPORT in_doubt_error : public failure
{
public:
  explicit in_doubt_error(const std::string &);
};


class PQXX_LIBEXPORT transaction_rollback : public failure
{
public:
  explicit transaction_rollback(const std::string &);
};



class PQXX_LIBEXPORT serialization_failure : public transaction_rollback
{
public:
  explicit serialization_failure(const std::string &);
};


class PQXX_LIBEXPORT statement_completion_unknown : public transaction_rollback
{
public:
  explicit statement_completion_unknown(const std::string &);
};


class PQXX_LIBEXPORT deadlock_detected : public transaction_rollback
{
public:
  explicit deadlock_detected(const std::string &);
};


class PQXX_LIBEXPORT internal_error :
  public pqxx_exception, public std::logic_error
{
  virtual const std::exception &base() const noexcept override
        { return *this; }
public:
  explicit internal_error(const std::string &);
};


class PQXX_LIBEXPORT usage_error :
  public pqxx_exception, public std::logic_error
{
  virtual const std::exception &base() const noexcept override
        { return *this; }
public:
  explicit usage_error(const std::string &);
};


class PQXX_LIBEXPORT argument_error :
  public pqxx_exception, public std::invalid_argument
{
  virtual const std::exception &base() const noexcept override
        { return *this; }
public:
  explicit argument_error(const std::string &);
};


class PQXX_LIBEXPORT conversion_error :
  public pqxx_exception, public std::domain_error
{
  virtual const std::exception &base() const noexcept override
        { return *this; }
public:
  explicit conversion_error(const std::string &);
};


class PQXX_LIBEXPORT range_error :
  public pqxx_exception, public std::out_of_range
{
  virtual const std::exception &base() const noexcept override
        { return *this; }
public:
  explicit range_error(const std::string &);
};


class PQXX_LIBEXPORT unexpected_rows : public range_error
{
  virtual const std::exception &base() const noexcept override
        { return *this; }
public:
  explicit unexpected_rows(const std::string &msg) : range_error(msg) {}
};


class PQXX_LIBEXPORT feature_not_supported : public sql_error
{
public:
  explicit feature_not_supported(
        const std::string &err,
        const std::string &Q="",
        const char sqlstate[]=nullptr) :
    sql_error(err, Q, sqlstate) {}
};

class PQXX_LIBEXPORT data_exception : public sql_error
{
public:
  explicit data_exception(
        const std::string &err,
        const std::string &Q="",
        const char sqlstate[]=nullptr) :
    sql_error(err, Q, sqlstate) {}
};

class PQXX_LIBEXPORT integrity_constraint_violation : public sql_error
{
public:
  explicit integrity_constraint_violation(
        const std::string &err,
        const std::string &Q="",
        const char sqlstate[]=nullptr) :
    sql_error(err, Q, sqlstate) {}
};

class PQXX_LIBEXPORT restrict_violation :
  public integrity_constraint_violation
{
public:
  explicit restrict_violation(
        const std::string &err,
        const std::string &Q="",
        const char sqlstate[]=nullptr) :
    integrity_constraint_violation(err, Q, sqlstate) {}
};

class PQXX_LIBEXPORT not_null_violation :
  public integrity_constraint_violation
{
public:
  explicit not_null_violation(
        const std::string &err,
        const std::string &Q="",
        const char sqlstate[]=nullptr) :
    integrity_constraint_violation(err, Q, sqlstate) {}
};

class PQXX_LIBEXPORT foreign_key_violation :
  public integrity_constraint_violation
{
public:
  explicit foreign_key_violation(
        const std::string &err,
        const std::string &Q="",
        const char sqlstate[]=nullptr) :
    integrity_constraint_violation(err, Q, sqlstate) {}
};

class PQXX_LIBEXPORT unique_violation :
  public integrity_constraint_violation
{
public:
  explicit unique_violation(
        const std::string &err,
        const std::string &Q="",
        const char sqlstate[]=nullptr) :
    integrity_constraint_violation(err, Q, sqlstate) {}
};

class PQXX_LIBEXPORT check_violation :
  public integrity_constraint_violation
{
public:
  explicit check_violation(
        const std::string &err,
        const std::string &Q="",
        const char sqlstate[]=nullptr) :
    integrity_constraint_violation(err, Q, sqlstate) {}
};

class PQXX_LIBEXPORT invalid_cursor_state : public sql_error
{
public:
  explicit invalid_cursor_state(
        const std::string &err,
        const std::string &Q="",
        const char sqlstate[]=nullptr) :
    sql_error(err, Q, sqlstate) {}
};

class PQXX_LIBEXPORT invalid_sql_statement_name : public sql_error
{
public:
  explicit invalid_sql_statement_name(
        const std::string &err,
        const std::string &Q="",
        const char sqlstate[]=nullptr) :
    sql_error(err, Q, sqlstate) {}
};

class PQXX_LIBEXPORT invalid_cursor_name : public sql_error
{
public:
  explicit invalid_cursor_name(
        const std::string &err,
        const std::string &Q="",
        const char sqlstate[]=nullptr) :
    sql_error(err, Q, sqlstate) {}
};

class PQXX_LIBEXPORT syntax_error : public sql_error
{
public:
  const int error_position;

  explicit syntax_error(
        const std::string &err,
        const std::string &Q="",
        const char sqlstate[]=nullptr,
        int pos=-1) :
    sql_error(err, Q, sqlstate), error_position(pos) {}
};

class PQXX_LIBEXPORT undefined_column : public syntax_error
{
public:
  explicit undefined_column(
        const std::string &err,
        const std::string &Q="",
        const char sqlstate[]=nullptr) :
    syntax_error(err, Q, sqlstate) {}
};

class PQXX_LIBEXPORT undefined_function : public syntax_error
{
public:
  explicit undefined_function(
        const std::string &err,
        const std::string &Q="",
        const char sqlstate[]=nullptr) :
    syntax_error(err, Q, sqlstate) {}
};

class PQXX_LIBEXPORT undefined_table : public syntax_error
{
public:
  explicit undefined_table(
        const std::string &err,
        const std::string &Q="",
        const char sqlstate[]=nullptr) :
    syntax_error(err, Q, sqlstate) {}
};

class PQXX_LIBEXPORT insufficient_privilege : public sql_error
{
public:
  explicit insufficient_privilege(
        const std::string &err,
        const std::string &Q="",
        const char sqlstate[]=nullptr) :
    sql_error(err, Q, sqlstate) {}
};

class PQXX_LIBEXPORT insufficient_resources : public sql_error
{
public:
  explicit insufficient_resources(
        const std::string &err,
        const std::string &Q="",
        const char sqlstate[]=nullptr) :
    sql_error(err,Q, sqlstate) {}
};

class PQXX_LIBEXPORT disk_full : public insufficient_resources
{
public:
  explicit disk_full(
        const std::string &err,
        const std::string &Q="",
        const char sqlstate[]=nullptr) :
    insufficient_resources(err, Q, sqlstate) {}
};

class PQXX_LIBEXPORT out_of_memory : public insufficient_resources
{
public:
  explicit out_of_memory(
        const std::string &err,
        const std::string &Q="",
        const char sqlstate[]=nullptr) :
    insufficient_resources(err, Q, sqlstate) {}
};

class PQXX_LIBEXPORT too_many_connections : public broken_connection
{
public:
  explicit too_many_connections(const std::string &err) :
        broken_connection(err) {}
};


class PQXX_LIBEXPORT plpgsql_error : public sql_error
{
public:
  explicit plpgsql_error(
        const std::string &err,
        const std::string &Q="",
        const char sqlstate[]=nullptr) :
    sql_error(err, Q, sqlstate) {}
};

class PQXX_LIBEXPORT plpgsql_raise : public plpgsql_error
{
public:
  explicit plpgsql_raise(
        const std::string &err,
        const std::string &Q="",
        const char sqlstate[]=nullptr) :
    plpgsql_error(err, Q, sqlstate) {}
};

class PQXX_LIBEXPORT plpgsql_no_data_found : public plpgsql_error
{
public:
  explicit plpgsql_no_data_found(
        const std::string &err,
        const std::string &Q="",
        const char sqlstate[]=nullptr) :
    plpgsql_error(err, Q, sqlstate) {}
};

class PQXX_LIBEXPORT plpgsql_too_many_rows : public plpgsql_error
{
public:
  explicit plpgsql_too_many_rows(
        const std::string &err,
        const std::string &Q="",
        const char sqlstate[]=nullptr) :
    plpgsql_error(err, Q, sqlstate) {}
};

}

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

#endif