Sqlite: Cleanup exceptions

There are now two base exceptions. Exception and ExceptionWithMessage.
We very often don't use the extra message. So don't pay for what you
don't use. Otherwise it is replacing code with using statements.

Change-Id: I213cf1f02718f6d3b2aa0e2a64626c9fc5c7c917
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>

src/libs/sqlite/sqlitedatabasebackend.cpp

@@ -297,7 +297,7 @@ void DatabaseBackend::checkDatabaseCouldBeOpened(int resultCode)
             return;
         default:
             closeWithoutException();
-            throw Exception(
+            throw UnknowError(
                 "SqliteDatabaseBackend::SqliteDatabaseBackend: database cannot be opened:",
                 sqlite3_errmsg(sqliteDatabaseHandle()));
         }
@@ -473,7 +473,7 @@ void DatabaseBackend::throwExceptionStatic(const char *whatHasHappens)
 void DatabaseBackend::throwException(const char *whatHasHappens) const
 {
     if (m_databaseHandle)
-        throw Exception(whatHasHappens, sqlite3_errmsg(m_databaseHandle));
+        throw ExceptionWithMessage(whatHasHappens, sqlite3_errmsg(m_databaseHandle));
     else
         throw Exception(whatHasHappens);
 }

src/libs/sqlite/sqliteexception.cpp

@@ -31,12 +31,9 @@
 
 namespace Sqlite {
 
-void Exception::printWarning() const
+void ExceptionWithMessage::printWarning() const
 {
-    if (!m_sqliteErrorMessage.isEmpty())
+    qWarning() << what() << m_sqliteErrorMessage;
-        qWarning() << m_whatErrorHasHappen << m_sqliteErrorMessage;
-    else
-        qWarning() << m_whatErrorHasHappen;
 }
 
 } // namespace Sqlite

src/libs/sqlite/sqliteexception.h

@@ -37,385 +37,293 @@ namespace Sqlite {
 class SQLITE_EXPORT Exception : public std::exception
 {
 public:
-    Exception(const char *whatErrorHasHappen, Utils::SmallString &&sqliteErrorMessage)
-        : m_whatErrorHasHappen(whatErrorHasHappen)
-        , m_sqliteErrorMessage(std::move(sqliteErrorMessage))
-    {}
-
     Exception(const char *whatErrorHasHappen)
         : m_whatErrorHasHappen(whatErrorHasHappen)
     {}
 
     const char *what() const noexcept override { return m_whatErrorHasHappen; }
 
+private:
+    const char *m_whatErrorHasHappen;
+};
+
+class SQLITE_EXPORT ExceptionWithMessage : public Exception
+{
+public:
+    ExceptionWithMessage(const char *whatErrorHasHappen,
+                         Utils::SmallString &&sqliteErrorMessage = Utils::SmallString{})
+        : Exception{whatErrorHasHappen}
+        , m_sqliteErrorMessage(std::move(sqliteErrorMessage))
+    {}
+
     void printWarning() const;
 
 private:
-    const char *m_whatErrorHasHappen;
     Utils::SmallString m_sqliteErrorMessage;
 };
 
-class StatementIsBusy : public Exception
+class StatementIsBusy : public ExceptionWithMessage
 {
 public:
-    StatementIsBusy(const char *whatErrorHasHappen,
+    using ExceptionWithMessage::ExceptionWithMessage;
-                    Utils::SmallString &&sqliteErrorMessage = Utils::SmallString())
-        : Exception(whatErrorHasHappen, std::move(sqliteErrorMessage))
-    {}
 };
 
 class DatabaseIsBusy : public Exception
 {
 public:
-    DatabaseIsBusy(const char *whatErrorHasHappen)
+    using Exception::Exception;
-        : Exception(whatErrorHasHappen)
-    {}
 };
 
-class StatementHasError : public Exception
+class StatementHasError : public ExceptionWithMessage
 {
 public:
-    StatementHasError(const char *whatErrorHasHappen,
+    using ExceptionWithMessage::ExceptionWithMessage;
-                      Utils::SmallString &&sqliteErrorMessage = Utils::SmallString())
-        : Exception(whatErrorHasHappen, std::move(sqliteErrorMessage))
-    {}
 };
 
-class StatementIsMisused : public Exception
+class StatementIsMisused : public ExceptionWithMessage
 {
 public:
-    StatementIsMisused(const char *whatErrorHasHappen,
+    using ExceptionWithMessage::ExceptionWithMessage;
-                       Utils::SmallString &&sqliteErrorMessage = Utils::SmallString())
-        : Exception(whatErrorHasHappen, std::move(sqliteErrorMessage))
-    {}
 };
 
 class InputOutputError : public Exception
 {
 public:
-    InputOutputError(const char *whatErrorHasHappen)
+    using Exception::Exception;
-        : Exception(whatErrorHasHappen)
-    {}
 };
 
-class ConstraintPreventsModification : public Exception
+class ConstraintPreventsModification : public ExceptionWithMessage
 {
 public:
-    ConstraintPreventsModification(const char *whatErrorHasHappen,
+    using ExceptionWithMessage::ExceptionWithMessage;
-                                   Utils::SmallString &&sqliteErrorMessage = Utils::SmallString())
-        : Exception(whatErrorHasHappen, std::move(sqliteErrorMessage))
-    {}
 };
 
 class NoValuesToFetch : public Exception
 {
 public:
-    NoValuesToFetch(const char *whatErrorHasHappen)
+    using Exception::Exception;
-        : Exception(whatErrorHasHappen)
-    {}
 };
 
 class ColumnCountDoesNotMatch : public Exception
 {
 public:
-    ColumnCountDoesNotMatch(const char *whatErrorHasHappen)
+    using Exception::Exception;
-        : Exception(whatErrorHasHappen)
-    {}
 };
 
-class BindingIndexIsOutOfRange : public Exception
+class BindingIndexIsOutOfRange : public ExceptionWithMessage
 {
 public:
-    BindingIndexIsOutOfRange(const char *whatErrorHasHappen,
+    using ExceptionWithMessage::ExceptionWithMessage;
-                             Utils::SmallString &&sqliteErrorMessage = Utils::SmallString())
-        : Exception(whatErrorHasHappen, std::move(sqliteErrorMessage))
-    {}
 };
 
 class WrongBindingName : public Exception
 {
 public:
-    WrongBindingName(const char *whatErrorHasHappen)
+    using Exception::Exception;
-        : Exception(whatErrorHasHappen)
-    {}
 };
 
 class DatabaseIsNotOpen : public Exception
 {
 public:
-    DatabaseIsNotOpen(const char *whatErrorHasHappen)
+    using Exception::Exception;
-        : Exception(whatErrorHasHappen)
-    {}
 };
 
-class DatabaseCannotBeOpened : public Exception
+class DatabaseCannotBeOpened : public ExceptionWithMessage
 {
 public:
-    DatabaseCannotBeOpened(const char *whatErrorHasHappen,
+    using ExceptionWithMessage::ExceptionWithMessage;
-                           Utils::SmallString &&errorMessage = Utils::SmallString())
-        : Exception(whatErrorHasHappen, std::move(errorMessage))
-    {}
 };
 
 class DatabaseFilePathIsEmpty : public DatabaseCannotBeOpened
 {
 public:
-    DatabaseFilePathIsEmpty(const char *whatErrorHasHappen)
+    using DatabaseCannotBeOpened::DatabaseCannotBeOpened;
-        : DatabaseCannotBeOpened(whatErrorHasHappen)
-    {}
 };
 
 class DatabaseIsAlreadyOpen : public DatabaseCannotBeOpened
 {
 public:
-    DatabaseIsAlreadyOpen(const char *whatErrorHasHappen)
+    using DatabaseCannotBeOpened::DatabaseCannotBeOpened;
-        : DatabaseCannotBeOpened(whatErrorHasHappen)
-    {}
 };
 
 class DatabaseCannotBeClosed : public Exception
 {
 public:
-    DatabaseCannotBeClosed(const char *whatErrorHasHappen)
+    using Exception::Exception;
-        : Exception(whatErrorHasHappen)
-    {}
 };
 
 class DatabaseIsAlreadyClosed : public DatabaseCannotBeClosed
 {
 public:
-    DatabaseIsAlreadyClosed(const char *whatErrorHasHappen)
+    using DatabaseCannotBeClosed::DatabaseCannotBeClosed;
-        : DatabaseCannotBeClosed(whatErrorHasHappen)
-    {}
 };
 
-class WrongFilePath : public DatabaseCannotBeOpened
+class WrongFilePath : public ExceptionWithMessage
 {
 public:
-    WrongFilePath(const char *whatErrorHasHappen,
+    using ExceptionWithMessage::ExceptionWithMessage;
-                  Utils::SmallString &&errorMessage = Utils::SmallString())
-        : DatabaseCannotBeOpened(whatErrorHasHappen, std::move(errorMessage))
-    {}
 };
 
 class PragmaValueNotSet : public Exception
 {
 public:
-    PragmaValueNotSet(const char *whatErrorHasHappen)
+    using Exception::Exception;
-        : Exception(whatErrorHasHappen)
-    {}
 };
 
 class NotReadOnlySqlStatement : public Exception
 {
 public:
-    NotReadOnlySqlStatement(const char *whatErrorHasHappen)
+    using Exception::Exception;
-        : Exception(whatErrorHasHappen)
-    {}
 };
 
 class NotWriteSqlStatement : public Exception
 {
 public:
-    NotWriteSqlStatement(const char *whatErrorHasHappen)
+    using Exception::Exception;
-        : Exception(whatErrorHasHappen)
-    {}
 };
 
 class DeadLock : public Exception
 {
 public:
-    DeadLock(const char *whatErrorHasHappen)
+    using Exception::Exception;
-        : Exception(whatErrorHasHappen)
-    {}
 };
 
-class UnknowError : public Exception
+class UnknowError : public ExceptionWithMessage
 {
 public:
-    UnknowError(const char *whatErrorHasHappen,
+    using ExceptionWithMessage::ExceptionWithMessage;
-                Utils::SmallString &&errorMessage = Utils::SmallString())
-        : Exception(whatErrorHasHappen, std::move(errorMessage))
-    {}
 };
 
-class BindingTooBig : public Exception
+class BindingTooBig : public ExceptionWithMessage
 {
 public:
-    BindingTooBig(const char *whatErrorHasHappen,
+    using ExceptionWithMessage::ExceptionWithMessage;
-                  Utils::SmallString &&errorMessage = Utils::SmallString())
-        : Exception(whatErrorHasHappen, std::move(errorMessage))
-    {}
 };
 
-class TooBig : public Exception
+class TooBig : public ExceptionWithMessage
 {
 public:
-    TooBig(const char *whatErrorHasHappen, Utils::SmallString &&errorMessage = Utils::SmallString())
+    using ExceptionWithMessage::ExceptionWithMessage;
-        : Exception(whatErrorHasHappen, std::move(errorMessage))
-    {}
 };
 
 class CannotConvert : public Exception
 {
 public:
-    CannotConvert(const char *whatErrorHasHappen)
+    using Exception::Exception;
-        : Exception(whatErrorHasHappen)
-    {}
 };
 
 class ForeignKeyColumnIsNotUnique : public Exception
 {
 public:
-    ForeignKeyColumnIsNotUnique(const char *whatErrorHasHappen)
+    using Exception::Exception;
-        : Exception(whatErrorHasHappen)
-    {}
 };
 
 class CannotApplyChangeSet : public Exception
 {
 public:
-    CannotApplyChangeSet(const char *whatErrorHasHappen)
+    using Exception::Exception;
-        : Exception(whatErrorHasHappen)
-    {}
 };
 
 class ChangeSetIsMisused : public Exception
 {
 public:
-    ChangeSetIsMisused(const char *whatErrorHasHappen)
+    using Exception::Exception;
-        : Exception(whatErrorHasHappen)
-    {}
 };
 
-class SchemeChangeError : public Exception
+class SchemeChangeError : public ExceptionWithMessage
 {
 public:
-    SchemeChangeError(const char *whatErrorHasHappen,
+    using ExceptionWithMessage::ExceptionWithMessage;
-                      Utils::SmallString &&errorMessage = Utils::SmallString())
-        : Exception(whatErrorHasHappen, std::move(errorMessage))
-    {}
 };
 
-class CannotWriteToReadOnlyConnection : public Exception
+class CannotWriteToReadOnlyConnection : public ExceptionWithMessage
 {
 public:
-    CannotWriteToReadOnlyConnection(const char *whatErrorHasHappen,
+    using ExceptionWithMessage::ExceptionWithMessage;
-                                    Utils::SmallString &&errorMessage = Utils::SmallString())
-        : Exception(whatErrorHasHappen, std::move(errorMessage))
-    {}
 };
 
-class ProtocolError : public Exception
+class ProtocolError : public ExceptionWithMessage
 {
 public:
-    ProtocolError(const char *whatErrorHasHappen,
+    using ExceptionWithMessage::ExceptionWithMessage;
-                  Utils::SmallString &&errorMessage = Utils::SmallString())
-        : Exception(whatErrorHasHappen, std::move(errorMessage))
-    {}
 };
 
-class DatabaseExceedsMaximumFileSize : public Exception
+class DatabaseExceedsMaximumFileSize : public ExceptionWithMessage
 {
 public:
-    DatabaseExceedsMaximumFileSize(const char *whatErrorHasHappen,
+    using ExceptionWithMessage::ExceptionWithMessage;
-                                   Utils::SmallString &&errorMessage = Utils::SmallString())
-        : Exception(whatErrorHasHappen, std::move(errorMessage))
-    {}
 };
 
-class DataTypeMismatch : public Exception
+class DataTypeMismatch : public ExceptionWithMessage
 {
 public:
-    DataTypeMismatch(const char *whatErrorHasHappen,
+    using ExceptionWithMessage::ExceptionWithMessage;
-                     Utils::SmallString &&errorMessage = Utils::SmallString())
-        : Exception(whatErrorHasHappen, std::move(errorMessage))
-    {}
 };
 
-class ConnectionIsLocked : public Exception
+class ConnectionIsLocked : public ExceptionWithMessage
 {
 public:
-    ConnectionIsLocked(const char *whatErrorHasHappen,
+    using ExceptionWithMessage::ExceptionWithMessage;
-                       Utils::SmallString &&errorMessage = Utils::SmallString())
-        : Exception(whatErrorHasHappen, std::move(errorMessage))
-    {}
 };
 
-class ExecutionInterrupted : public Exception
+class ExecutionInterrupted : public ExceptionWithMessage
 {
 public:
-    ExecutionInterrupted(const char *whatErrorHasHappen,
+    using ExceptionWithMessage::ExceptionWithMessage;
-                         Utils::SmallString &&errorMessage = Utils::SmallString())
-        : Exception(whatErrorHasHappen, std::move(errorMessage))
-    {}
 };
 
-class DatabaseIsCorrupt : public Exception
+class DatabaseIsCorrupt : public ExceptionWithMessage
 {
 public:
-    DatabaseIsCorrupt(const char *whatErrorHasHappen,
+    using ExceptionWithMessage::ExceptionWithMessage;
-                      Utils::SmallString &&errorMessage = Utils::SmallString())
-        : Exception(whatErrorHasHappen, std::move(errorMessage))
-    {}
 };
 
-class CannotOpen : public Exception
+class CannotOpen : public ExceptionWithMessage
 {
 public:
-    CannotOpen(const char *whatErrorHasHappen,
+    using ExceptionWithMessage::ExceptionWithMessage;
-               Utils::SmallString &&errorMessage = Utils::SmallString())
-        : Exception(whatErrorHasHappen, std::move(errorMessage))
-    {}
 };
 
 class CannotCreateChangeSetIterator : public Exception
 {
 public:
-    CannotCreateChangeSetIterator(const char *whatErrorHasHappen)
+    using Exception::Exception;
-        : Exception(whatErrorHasHappen)
-    {}
 };
 
 class CannotGetChangeSetOperation : public Exception
 {
 public:
-    CannotGetChangeSetOperation(const char *whatErrorHasHappen)
+    using Exception::Exception;
-        : Exception(whatErrorHasHappen)
-    {}
 };
 
 class ChangeSetTupleIsOutOfRange : public Exception
 {
 public:
-    ChangeSetTupleIsOutOfRange(const char *whatErrorHasHappen)
+    using Exception::Exception;
-        : Exception(whatErrorHasHappen)
-    {}
 };
 
 class ChangeSetTupleIsMisused : public Exception
 {
 public:
-    ChangeSetTupleIsMisused(const char *whatErrorHasHappen)
+    using Exception::Exception;
-        : Exception(whatErrorHasHappen)
-
-    {}
 };
 
 class UnknownError : public Exception
 {
 public:
-    UnknownError(const char *whatErrorHasHappen)
+    using Exception::Exception;
-        : Exception(whatErrorHasHappen)
-    {}
 };
 
 class DatabaseIsNotLocked : public Exception
 {
 public:
-    DatabaseIsNotLocked(const char *whatErrorHasHappen)
+    using Exception::Exception;
-        : Exception(whatErrorHasHappen)
+};
-    {}
+
+class WrongBindingParameterCount : public Exception
+{
+public:
+    using Exception::Exception;
 };
 
 } // namespace Sqlite

src/libs/sqlite/sqlstatementbuilderexception.h

@@ -29,10 +29,10 @@
 
 namespace Sqlite {
 
-class SQLITE_EXPORT SqlStatementBuilderException : public Exception
+class SQLITE_EXPORT SqlStatementBuilderException : public ExceptionWithMessage
 {
 public:
-    using Exception::Exception;
+    using ExceptionWithMessage::ExceptionWithMessage;
 };
 
 } // namespace Sqlite