Qt SQL Streaming Database Solutions

I am creating a Qt-based application for monitoring and collecting data streams from a serial port. Data is displayed in real time, sent via TCP and stored in the SQLite database. Unfortunately, I found that SQLite inserts cause the GUI to stop responding because I am processing serial data, plotting, transmitting TCP and inserting the database in the context of the main loop. I explored splitting the database insert into another thread and came up with the following code.

 #include <QObject>
#include <QDebug>
#include <QStringList>
#include <QSqlDatabase>
#include <QSqlQuery>
#include <QSqlError>
#include <QVariant>
#include <QObject>
#include <QList>
#include <QThread>
#include <QMutex>
#include <QWaitCondition>
#include <QSqlDatabase>
#include <QSqlRecord>
#include <QString>
#include "mMessage.h"
// The class that does all the work with the database. This class will
// be instantiated in the thread object run() method.
class Worker : public QObject
{
  Q_OBJECT
   public:
    Worker( QObject* parent = 0);
    ~Worker();
    bool insertADC(mMessage* insertMessage);
  public slots:
    void slotExecute( mMessage* insertMessage );
  signals:
    void queryResult(bool);
   private:
     QSqlDatabase m_database;
     bool m_databaseOpen;
     void prepareQueries();
     QSqlQuery *m_accelerometerQuery;
     QSqlQuery *m_adcQuery;
     QSqlQuery *m_metricsQuery;
     QSqlQuery *m_rssiQuery;
};

class mDatabaseThread : public QThread
{
  Q_OBJECT
  public:
    mDatabaseThread(QObject *parent = 0);
    ~mDatabaseThread();
    void executeInsertion( mMessage* insertMessage );
  signals:
    void progress( const QString& msg );
void ready(bool);
  protected:
    void run();
  signals:
    void executefwd( mMessage* insertMessage );
  private:
     Worker* m_worker;
};

CPP FILE

    #include "mDatabaseThread.h"
    //

    Worker::Worker( QObject* parent )
        : QObject( parent )
    {
        // thread-specific connection, see db.h
        m_database = QSqlDatabase::addDatabase( "QSQLITE",
                                                "WorkerDatabase" ); // named connection
        m_database.setDatabaseName("trainingX.db3");
        if ( !m_database.open() )
        {
            qWarning() << "Unable to connect to database, giving up:" << m_database.lastError().text();
            m_databaseOpen = false;
            return;
        }
     m_databaseOpen = true;

    }

    Worker::~Worker()
    {
        //close the database
       // m_database.close();
       // m_database.removeDatabase("trainingX.db3");
    }
    void Worker::prepareQueries()
    {
        if (m_databaseOpen)
        {
        m_accelerometerQuery->prepare("INSERT INTO accelerometer (key, timestamp, nickname, unitid,"
                                   "sectorid, acc_x, acc_y, acc_z) "
                                   "VALUES (NULL, :timestamp, :nickname, :unitid, :sectorid,"
                                   ":acc_x, :acc_y, :acc_z)");

        m_adcQuery->prepare("INSERT INTO adc (key, timestamp, nickname, unitid, sectorid,"
                         "adc0, adc1, adc2, adc3, adc4, adc5, adc6, adc7) "
                         "VALUES (NULL, :timestamp, :nickname, :unitid, :sectorid,"
                         ":adc0, :adc1, :adc2, :adc3, :adc4, :adc5, :adc6, :adc7)");

        m_metricsQuery->prepare("INSERT INTO metrics (key, timestamp, nickname, unitid, sectorid, "
                             "acc_temp, unit_temp, unit_pressure, bpm_instant, bpm_average, base_pressure, base_temp) "
                             "VALUES (NULL, :timestamp, :nickname, :unitid, :sectorid,"
                             ":acc_temp, :unit_temp, :unit_pressure, :bpm_instant, :bpm_average, :base_pressure, :base_temp)");

        m_rssiQuery->prepare("INSERT INTO rssi (key, timestamp, nickname, unitid, sectorid, "
                          "rssi_1, rssi_2, rssi_3, rssi_4, rssi_avg) "
                          "VALUES (NULL, :timestamp, :nickname, :unitid, :sectorid,"
                          ":rssi_1, :rssi_2, :rssi_3, :rssi_4, :rssi_avg)");
        }
    }

    void Worker::slotExecute( mMessage* insertMessage )
    {
        m_accelerometerQuery = new QSqlQuery("WorkerDatabase");
        m_adcQuery = new QSqlQuery("WorkerDatabase");
        m_metricsQuery = new QSqlQuery("WorkerDatabase");
        m_rssiQuery = new QSqlQuery("WorkerDatabase");

        prepareQueries();

        insertADC(insertMessage);
        //insertRSSI(insertMessage);
        //insertAccelerometer(insertMessage);
        //insertMetrics(insertMessage);
        emit queryResult( true );
    }
bool Worker::insertADC(mMessage *insertMessage)
{
    if (m_databaseOpen)
    {
           // m_adcQuery->bindValue(":key",0);
            m_adcQuery->bindValue(":timestamp",insertMessage->m_timestamp);
            m_adcQuery->bindValue(":nickname",insertMessage->m_nickname);
            m_adcQuery->bindValue(":unitid",insertMessage->m_unitId.toInt());
            m_adcQuery->bindValue(":sectorid",insertMessage->m_sectorId.toInt());
            m_adcQuery->bindValue(":adc0",insertMessage->m_adc0.toInt());
            m_adcQuery->bindValue(":adc1",insertMessage->m_adc1.toInt());
            m_adcQuery->bindValue(":adc2",insertMessage->m_adc2.toInt());
            m_adcQuery->bindValue(":adc3",insertMessage->m_adc3.toInt());
            m_adcQuery->bindValue(":adc4",insertMessage->m_adc4.toInt());
            m_adcQuery->bindValue(":adc5",insertMessage->m_adc5.toInt());
            m_adcQuery->bindValue(":adc6",insertMessage->m_adc6.toInt());
            m_adcQuery->bindValue(":adc7",insertMessage->m_adc7.toInt());
            if (m_adcQuery->exec())
            {
                return true;
            }
            else
            {
                qDebug() << "SQL ADC failed.";
                qDebug() << m_adcQuery->lastError();
                return false;
            }
    }
    else
    {
    //database isn't open
    return false;
    }
}
////database thread

mDatabaseThread::mDatabaseThread(QObject *parent)
    : QThread(parent)
{
}
mDatabaseThread::~mDatabaseThread()
{
    delete m_worker;
}

void mDatabaseThread::executeInsertion( mMessage* insertMessage )
{
    emit executefwd( insertMessage ); // forwards to the worker
}

void mDatabaseThread::run()
{
    emit ready(false);
     // Create worker object within the context of the new thread
    m_worker = new Worker();
    connect( this, SIGNAL( executefwd( mMessage* ) ),
             m_worker, SLOT( slotExecute( mMessage* ) ) );
    connect( m_worker, SIGNAL(queryResult(bool)), this, SIGNAL(ready(bool)));
    emit ready(true);

    exec();  // our event loop
}

mDatabaseThread , . . , QSqlQuery , , , , m_database /. http://www.linuxjournal.com/article/9602. mMessage - qObject, m_worker.

m_databaseThread- > start() , executeInsertion (mMessage *). m_database, QSqlQueries, , , , , , QSqlQuery .