SqliteConnection.h

Go to the documentation of this file.

#ifndef ZSERIO_SQL_CONNECTION_H_INC
#define ZSERIO_SQL_CONNECTION_H_INC
 
#include <memory>
#include <string_view>
 
#include "zserio/SqliteException.h"
#include "zserio/SqliteFinalizer.h"
 
#include "sqlite3.h"
 
namespace zserio
{
 
class SqliteConnection
{
public:
    enum ConnectionType
    {
        INTERNAL_CONNECTION, 
        EXTERNAL_CONNECTION 
    };
 
    explicit SqliteConnection(
            sqlite3* connection = nullptr, ConnectionType connectionType = INTERNAL_CONNECTION);
 
    ~SqliteConnection();
 
    SqliteConnection(const SqliteConnection&) = delete;
    SqliteConnection& operator=(const SqliteConnection&) = delete;
 
    SqliteConnection(SqliteConnection&&) = delete;
    SqliteConnection& operator=(SqliteConnection&&) = delete;
    void reset(sqlite3* connection = nullptr, ConnectionType connectionType = INTERNAL_CONNECTION);
 
    ConnectionType getConnectionType() const;
 
    sqlite3* getConnection();
 
    void executeUpdate(std::string_view sqlQuery);
 
    sqlite3_stmt* prepareStatement(std::string_view sqlQuery);
 
    bool startTransaction();
 
    void endTransaction(bool wasTransactionStarted);
 
private:
    sqlite3* m_connection;
    ConnectionType m_connectionType;
};
 
inline SqliteConnection::SqliteConnection(sqlite3* connection, ConnectionType connectionType) :
        m_connection(connection),
        m_connectionType(connectionType)
{}
 
inline SqliteConnection::~SqliteConnection()
{
    reset();
}
 
inline void SqliteConnection::reset(sqlite3* connection, ConnectionType connectionType)
{
    // close connection only if it is internal
    if (m_connectionType == INTERNAL_CONNECTION)
    {
        sqlite3_close_v2(m_connection); // sqlite3_close_v2(NULL) is a harmless no-op
    }
 
    m_connection = connection;
    m_connectionType = connectionType;
}
 
inline SqliteConnection::ConnectionType SqliteConnection::getConnectionType() const
{
    return m_connectionType;
}
 
inline sqlite3* SqliteConnection::getConnection()
{
    return m_connection;
}
 
inline void SqliteConnection::executeUpdate(std::string_view sqlQuery)
{
    std::unique_ptr<sqlite3_stmt, SqliteFinalizer> statement(prepareStatement(sqlQuery));
    int result = sqlite3_step(statement.get());
    if (result != SQLITE_DONE)
    {
        throw SqliteException("SqliteConnection::executeUpdate(): sqlite3_step failed: ")
                << SqliteErrorCode(result);
    }
}
 
inline sqlite3_stmt* SqliteConnection::prepareStatement(std::string_view sqlQuery)
{
    sqlite3_stmt* statement = nullptr;
    const int result = sqlite3_prepare_v2(
            m_connection, sqlQuery.data(), static_cast<int>(sqlQuery.size()), &statement, nullptr);
    if (result != SQLITE_OK)
    {
        throw SqliteException("SqliteConnection::prepareStatement(): sqlite3_prepare_v2() failed: ")
                << SqliteErrorCode(result);
    }
 
    return statement;
}
 
inline bool SqliteConnection::startTransaction()
{
    bool wasTransactionStarted = false;
    if (sqlite3_get_autocommit(m_connection) != 0)
    {
        executeUpdate("BEGIN;");
        wasTransactionStarted = true;
    }
 
    return wasTransactionStarted;
}
 
inline void SqliteConnection::endTransaction(bool wasTransactionStarted)
{
    if (wasTransactionStarted)
    {
        executeUpdate("COMMIT;");
    }
}
 
} // namespace zserio
 
#endif // ZSERIO_SQL_CONNECTION_H_INC