Exception.h

Go to the documentation of this file.

 
// taken from libpqxx and modified

 
#pragma once
 
#include <drogon/exports.h>
#include <functional>
#include <stdexcept>
#include <string>
 
namespace drogon
{
namespace orm
{

class DROGON_EXPORT DrogonDbException
{
  public:
    virtual ~DrogonDbException() noexcept
    {
    }


    virtual const std::exception &base() const noexcept
    {
        static std::exception except;
        return except;
    }  //[t00]
};

class Failure : public DrogonDbException, public std::runtime_error
{
    const std::exception &base() const noexcept override
    {
        return *this;
    }
 
  public:
    DROGON_EXPORT explicit Failure(const std::string &);
};


class BrokenConnection : public Failure
{
  public:
    DROGON_EXPORT BrokenConnection();
    DROGON_EXPORT explicit BrokenConnection(const std::string &);
};


class SqlError : public Failure
{
    const std::string query_;
    const std::string sqlState_;
 
    const int errcode_{0};
    const int extendedErrcode_{0};
 
  public:
    DROGON_EXPORT explicit SqlError(const std::string &msg = "",
                                    const std::string &Q = "",
                                    const char sqlstate[] = nullptr);
    DROGON_EXPORT explicit SqlError(const std::string &msg,
                                    const std::string &Q,
                                    const int errcode,
                                    const int extendedErrcode);
    DROGON_EXPORT virtual ~SqlError() noexcept;

    DROGON_EXPORT const std::string &query() const noexcept;
    DROGON_EXPORT const std::string &sqlState() const noexcept;
    DROGON_EXPORT int errcode() const noexcept;
    DROGON_EXPORT int extendedErrcode() const noexcept;
};


class InDoubtError : public Failure
{
  public:
    DROGON_EXPORT explicit InDoubtError(const std::string &);
};

class TransactionRollback : public Failure
{
  public:
    DROGON_EXPORT explicit TransactionRollback(const std::string &);
};


class SerializationFailure : public TransactionRollback
{
  public:
    DROGON_EXPORT explicit SerializationFailure(const std::string &);
};

class StatementCompletionUnknown : public TransactionRollback
{
  public:
    DROGON_EXPORT explicit StatementCompletionUnknown(const std::string &);
};

class DeadlockDetected : public TransactionRollback
{
  public:
    DROGON_EXPORT explicit DeadlockDetected(const std::string &);
};

class InternalError : public DrogonDbException, public std::logic_error
{
    const std::exception &base() const noexcept override
    {
        return *this;
    }
 
  public:
    DROGON_EXPORT explicit InternalError(const std::string &);
};

class TimeoutError : public DrogonDbException, public std::logic_error
{
    const std::exception &base() const noexcept override
    {
        return *this;
    }
 
  public:
    DROGON_EXPORT explicit TimeoutError(const std::string &);
};

class UsageError : public DrogonDbException, public std::logic_error
{
    const std::exception &base() const noexcept override
    {
        return *this;
    }
 
  public:
    DROGON_EXPORT explicit UsageError(const std::string &);
};

class ArgumentError : public DrogonDbException, public std::invalid_argument
{
    const std::exception &base() const noexcept override
    {
        return *this;
    }
 
  public:
    DROGON_EXPORT explicit ArgumentError(const std::string &);
};

class ConversionError : public DrogonDbException, public std::domain_error
{
    const std::exception &base() const noexcept override
    {
        return *this;
    }
 
  public:
    DROGON_EXPORT explicit ConversionError(const std::string &);
};

class RangeError : public DrogonDbException, public std::out_of_range
{
    const std::exception &base() const noexcept override
    {
        return *this;
    }
 
  public:
    DROGON_EXPORT explicit RangeError(const std::string &);
};

class UnexpectedRows : public RangeError
{
    const std::exception &base() const noexcept override
    {
        return *this;
    }
 
  public:
    explicit UnexpectedRows(const std::string &msg) : RangeError(msg)
    {
    }
};

class FeatureNotSupported : public SqlError
{
  public:
    explicit FeatureNotSupported(const std::string &err,
                                 const std::string &Q = "",
                                 const char sqlstate[] = nullptr)
        : SqlError(err, Q, sqlstate)
    {
    }
 
    explicit FeatureNotSupported(const std::string &msg,
                                 const std::string &Q,
                                 const int errcode,
                                 const int extendedErrcode)
        : SqlError(msg, Q, errcode, extendedErrcode)
    {
    }
};

class DataException : public SqlError
{
  public:
    explicit DataException(const std::string &err,
                           const std::string &Q = "",
                           const char sqlstate[] = nullptr)
        : SqlError(err, Q, sqlstate)
    {
    }
 
    explicit DataException(const std::string &msg,
                           const std::string &Q,
                           const int errcode,
                           const int extendedErrcode)
        : SqlError(msg, Q, errcode, extendedErrcode)
    {
    }
};
 
class IntegrityConstraintViolation : public SqlError
{
  public:
    explicit IntegrityConstraintViolation(const std::string &err,
                                          const std::string &Q = "",
                                          const char sqlstate[] = nullptr)
        : SqlError(err, Q, sqlstate)
    {
    }
 
    explicit IntegrityConstraintViolation(const std::string &msg,
                                          const std::string &Q,
                                          const int errcode,
                                          const int extendedErrcode)
        : SqlError(msg, Q, errcode, extendedErrcode)
    {
    }
};
 
class RestrictViolation : public IntegrityConstraintViolation
{
  public:
    explicit RestrictViolation(const std::string &err,
                               const std::string &Q = "",
                               const char sqlstate[] = nullptr)
        : IntegrityConstraintViolation(err, Q, sqlstate)
    {
    }
 
    explicit RestrictViolation(const std::string &msg,
                               const std::string &Q,
                               const int errcode,
                               const int extendedErrcode)
        : IntegrityConstraintViolation(msg, Q, errcode, extendedErrcode)
    {
    }
};
 
class NotNullViolation : public IntegrityConstraintViolation
{
  public:
    explicit NotNullViolation(const std::string &err,
                              const std::string &Q = "",
                              const char sqlstate[] = nullptr)
        : IntegrityConstraintViolation(err, Q, sqlstate)
    {
    }
 
    explicit NotNullViolation(const std::string &msg,
                              const std::string &Q,
                              const int errcode,
                              const int extendedErrcode)
        : IntegrityConstraintViolation(msg, Q, errcode, extendedErrcode)
    {
    }
};
 
class ForeignKeyViolation : public IntegrityConstraintViolation
{
  public:
    explicit ForeignKeyViolation(const std::string &err,
                                 const std::string &Q = "",
                                 const char sqlstate[] = nullptr)
        : IntegrityConstraintViolation(err, Q, sqlstate)
    {
    }
 
    explicit ForeignKeyViolation(const std::string &msg,
                                 const std::string &Q,
                                 const int errcode,
                                 const int extendedErrcode)
        : IntegrityConstraintViolation(msg, Q, errcode, extendedErrcode)
    {
    }
};
 
class UniqueViolation : public IntegrityConstraintViolation
{
  public:
    explicit UniqueViolation(const std::string &err,
                             const std::string &Q = "",
                             const char sqlstate[] = nullptr)
        : IntegrityConstraintViolation(err, Q, sqlstate)
    {
    }
 
    explicit UniqueViolation(const std::string &msg,
                             const std::string &Q,
                             const int errcode,
                             const int extendedErrcode)
        : IntegrityConstraintViolation(msg, Q, errcode, extendedErrcode)
    {
    }
};
 
class CheckViolation : public IntegrityConstraintViolation
{
  public:
    explicit CheckViolation(const std::string &err,
                            const std::string &Q = "",
                            const char sqlstate[] = nullptr)
        : IntegrityConstraintViolation(err, Q, sqlstate)
    {
    }
 
    explicit CheckViolation(const std::string &msg,
                            const std::string &Q,
                            const int errcode,
                            const int extendedErrcode)
        : IntegrityConstraintViolation(msg, Q, errcode, extendedErrcode)
    {
    }
};
 
class InvalidCursorState : public SqlError
{
  public:
    explicit InvalidCursorState(const std::string &err,
                                const std::string &Q = "",
                                const char sqlstate[] = nullptr)
        : SqlError(err, Q, sqlstate)
    {
    }
 
    explicit InvalidCursorState(const std::string &msg,
                                const std::string &Q,
                                const int errcode,
                                const int extendedErrcode)
        : SqlError(msg, Q, errcode, extendedErrcode)
    {
    }
};
 
class InvalidSqlStatementName : public SqlError
{
  public:
    explicit InvalidSqlStatementName(const std::string &err,
                                     const std::string &Q = "",
                                     const char sqlstate[] = nullptr)
        : SqlError(err, Q, sqlstate)
    {
    }
 
    explicit InvalidSqlStatementName(const std::string &msg,
                                     const std::string &Q,
                                     const int errcode,
                                     const int extendedErrcode)
        : SqlError(msg, Q, errcode, extendedErrcode)
    {
    }
};
 
class InvalidCursorName : public SqlError
{
  public:
    explicit InvalidCursorName(const std::string &err,
                               const std::string &Q = "",
                               const char sqlstate[] = nullptr)
        : SqlError(err, Q, sqlstate)
    {
    }
 
    explicit InvalidCursorName(const std::string &msg,
                               const std::string &Q,
                               const int errcode,
                               const int extendedErrcode)
        : SqlError(msg, Q, errcode, extendedErrcode)
    {
    }
};
 
class SyntaxError : public SqlError
{
  public:
    const int errorPosition_;
 
    explicit SyntaxError(const std::string &err,
                         const std::string &Q = "",
                         const char sqlstate[] = nullptr,
                         int pos = -1)
        : SqlError(err, Q, sqlstate), errorPosition_(pos)
    {
    }
 
    explicit SyntaxError(const std::string &msg,
                         const std::string &Q,
                         const int errcode,
                         const int extendedErrcode,
                         int pos = -1)
        : SqlError(msg, Q, errcode, extendedErrcode), errorPosition_(pos)
    {
    }
};
 
class UndefinedColumn : public SyntaxError
{
  public:
    explicit UndefinedColumn(const std::string &err,
                             const std::string &Q = "",
                             const char sqlstate[] = nullptr)
        : SyntaxError(err, Q, sqlstate)
    {
    }
 
    explicit UndefinedColumn(const std::string &msg,
                             const std::string &Q,
                             const int errcode,
                             const int extendedErrcode)
        : SyntaxError(msg, Q, errcode, extendedErrcode)
    {
    }
};
 
class UndefinedFunction : public SyntaxError
{
  public:
    explicit UndefinedFunction(const std::string &err,
                               const std::string &Q = "",
                               const char sqlstate[] = nullptr)
        : SyntaxError(err, Q, sqlstate)
    {
    }
 
    explicit UndefinedFunction(const std::string &msg,
                               const std::string &Q,
                               const int errcode,
                               const int extendedErrcode)
        : SyntaxError(msg, Q, errcode, extendedErrcode)
    {
    }
};
 
class UndefinedTable : public SyntaxError
{
  public:
    explicit UndefinedTable(const std::string &err,
                            const std::string &Q = "",
                            const char sqlstate[] = nullptr)
        : SyntaxError(err, Q, sqlstate)
    {
    }
 
    explicit UndefinedTable(const std::string &msg,
                            const std::string &Q,
                            const int errcode,
                            const int extendedErrcode)
        : SyntaxError(msg, Q, errcode, extendedErrcode)
    {
    }
};
 
class InsufficientPrivilege : public SqlError
{
  public:
    explicit InsufficientPrivilege(const std::string &err,
                                   const std::string &Q = "",
                                   const char sqlstate[] = nullptr)
        : SqlError(err, Q, sqlstate)
    {
    }
 
    explicit InsufficientPrivilege(const std::string &msg,
                                   const std::string &Q,
                                   const int errcode,
                                   const int extendedErrcode)
        : SqlError(msg, Q, errcode, extendedErrcode)
    {
    }
};

class InsufficientResources : public SqlError
{
  public:
    explicit InsufficientResources(const std::string &err,
                                   const std::string &Q = "",
                                   const char sqlstate[] = nullptr)
        : SqlError(err, Q, sqlstate)
    {
    }
 
    explicit InsufficientResources(const std::string &msg,
                                   const std::string &Q,
                                   const int errcode,
                                   const int extendedErrcode)
        : SqlError(msg, Q, errcode, extendedErrcode)
    {
    }
};
 
class DiskFull : public InsufficientResources
{
  public:
    explicit DiskFull(const std::string &err,
                      const std::string &Q = "",
                      const char sqlstate[] = nullptr)
        : InsufficientResources(err, Q, sqlstate)
    {
    }
 
    explicit DiskFull(const std::string &msg,
                      const std::string &Q,
                      const int errcode,
                      const int extendedErrcode)
        : InsufficientResources(msg, Q, errcode, extendedErrcode)
    {
    }
};
 
class OutOfMemory : public InsufficientResources
{
  public:
    explicit OutOfMemory(const std::string &err,
                         const std::string &Q = "",
                         const char sqlstate[] = nullptr)
        : InsufficientResources(err, Q, sqlstate)
    {
    }
 
    explicit OutOfMemory(const std::string &msg,
                         const std::string &Q,
                         const int errcode,
                         const int extendedErrcode)
        : InsufficientResources(msg, Q, errcode, extendedErrcode)
    {
    }
};
 
class TooManyConnections : public BrokenConnection
{
  public:
    explicit TooManyConnections(const std::string &err) : BrokenConnection(err)
    {
    }
};
 
// /// PL/pgSQL error
// /** Exceptions derived from this class are errors from PL/pgSQL procedures.
//  */
// 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) {}
// };
 
// /// Exception raised in PL/pgSQL procedure
// 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) {}
// };
using DrogonDbExceptionCallback =
    std::function<void(const DrogonDbException &)>;
}  // namespace orm
}  // namespace drogon