"""
`DB-API <http://www.python.org/peps/pep-0249.html>`_ exceptions.

This is the exception inheritance layout::

    StandardError
    |__Warning
    |__Error
       |__InterfaceError
       |__DatabaseError
          |__DataError
          |__OperationalError
          |__IntegrityError
          |__InternalError
          |__ProgrammingError
          |__NotSupportedError
"""

class Warning(StandardError):
    """
    Exception raised for important warnings like data
    truncations while inserting, etc. It must be a subclass of
    the Python StandardError (defined in the module
    exceptions).
    """
            
class Error(StandardError):
    """
    Exception that is the base class of all other error
    exceptions. You can use this to catch all errors with one
    single 'except' statement. Warnings are not considered
    errors and thus should not use this class as base. It must
    be a subclass of the Python StandardError (defined in the
    module exceptions).
    """
    
class InterfaceError(Error):
    """
    Exception raised for errors that are related to the
    database interface rather than the database itself.  It
    must be a subclass of Error.
    """
    
class DatabaseError(Error):
    """
    Exception raised for errors that are related to the
    database.  It must be a subclass of Error.
    """
    
class DataError(DatabaseError):
    """
    Exception raised for errors that are due to problems with
    the processed data like division by zero, numeric value
    out of range, etc. It must be a subclass of DatabaseError.
    """

class OperationalError(DatabaseError):
    """
    Exception raised for errors that are related to the
    database's operation and not necessarily under the control
    of the programmer, e.g. an unexpected disconnect occurs,
    the data source name is not found, a transaction could not
    be processed, a memory allocation error occurred during
    processing, etc.  It must be a subclass of DatabaseError.
    """
    
class IntegrityError(DatabaseError):
    """
    Exception raised when the relational integrity of the
    database is affected, e.g. a foreign key check fails.  It
    must be a subclass of DatabaseError.
    """

class InternalError(DatabaseError):
    """
    Exception raised when the database encounters an internal
    error, e.g. the cursor is not valid anymore, the
    transaction is out of sync, etc.  It must be a subclass of
    DatabaseError.
    """

class ProgrammingError(DatabaseError):
    """
    Exception raised for programming errors, e.g. table not
    found or already exists, syntax error in the SQL
    statement, wrong number of parameters specified, etc.  It
    must be a subclass of DatabaseError.
    """

class NotSupportedError(DatabaseError):
    """
    Exception raised in case a method or database API was used
    which is not supported by the database, e.g. requesting a
    .rollback() on a connection that does not support
    transaction or has transactions turned off.  It must be a
    subclass of DatabaseError.
    """

def _insert_base(exc, base):
    exc.__bases__ = exc.__bases__ + (base,)

def install_exception_hierarchy(db_mod):
    """
    This takes the given DB-API compliant module, and makes sure that
    the exceptions inherit from the exceptions defined here.
    """
    _insert_base(db_mod.Warning, Warning)
    _insert_base(db_mod.Error, Error)
    _insert_base(db_mod.InterfaceError, InterfaceError)
    _insert_base(db_mod.DatabaseError, DatabaseError)
    _insert_base(db_mod.DataError, DataError)
    _insert_base(db_mod.OperationalError, OperationalError)
    _insert_base(db_mod.IntegrityError, IntegrityError)
    _insert_base(db_mod.InternalError, InternalError)
    _insert_base(db_mod.ProgrammingError, ProgrammingError)
    _insert_base(db_mod.NotSupportedError, NotSupportedError)