modularization/src/driver/driver_group_grpc_server/groupdb.cpp

#include "groupdb.h"

#include <QDateTime>

#include <QDir>

groupdb::groupdb(std::string strdbpath)
{
    mstrdbpath = strdbpath;

}


void groupdb::OpenDataBase()
{
    mbSQL = false;

    msleep(100);


    if(QSqlDatabase::contains("sqliteadc"))
        mdatabase = QSqlDatabase::database("sqliteadc");
    else
        mdatabase = QSqlDatabase::addDatabase("QSQLITE","sqliteadc");
//    mdatabase = QSqlDatabase::addDatabase("QSQLITE");


//    if(QSqlDatabase::contains("sqlite"))
//        mdatabase = QSqlDatabase::database("sqlite");
//    else
//        mdatabase = QSqlDatabase::addDatabase("QSQLITE","sqlite");



    mdatabase.setDatabaseName(mstrdbpath.data());
    if (!mdatabase.open())
    {
        qDebug("Error: Failed to connect database. error is %s ",mdatabase.lastError());
        return;
    }
    else
    {

        qDebug("Succeed to connect database.");
    }



    QSqlQuery sql_query(mdatabase);

    bool bHaveTable = true;

    //查询数据
    sql_query.exec("select count(*)  from sqlite_master where type='table' and name = 'groupdata'");
    if(!sql_query.exec())
    {
        qDebug("%s",sql_query.lastError());
        return;
    }
    else
    {

        if(sql_query.next())
        {
            int count = sql_query.value(0).toInt();
//            qDebug("count %d ",count);
            if(count < 1)bHaveTable = false;
        }
    }



    if(bHaveTable == false)
    {
        if(!sql_query.exec("create table groupdata(id INTEGER primary key AUTOINCREMENT,recordid BIGINT, vehid TEXT,"
                           "recvtime BIGINT,msgtime BIGINT,groupid INTEGER,"
                           "intragroupid INTEGER,vehdata BLOB)"))
        {
            qDebug() << "Error: Fail to create table."<< sql_query.lastError();
            return;
        }
        if(!sql_query.exec("CREATE INDEX index_vehid ON groupdata (vehid)"))
        {
            qDebug() << "Error: Fail to create index_vehid."<< sql_query.lastError();
            return;
        }
        if(!sql_query.exec("CREATE INDEX index_recvtime ON groupdata (recvtime)"))
        {
            qDebug() << "Error: Fail to create index_recvtime."<< sql_query.lastError();
            return;
        }
        if(!sql_query.exec("CREATE INDEX index_recordid ON groupdata (recordid)"))
        {
            qDebug() << "Error: Fail to create index_recordid."<< sql_query.lastError();
            return;
        }
        qDebug("Create Table groupdata successfully.");
    }

    //查询数据
    sql_query.exec("select count(*)  from sqlite_master where type='table' and name = 'recorddata'");
    if(!sql_query.exec())
    {
        qDebug("%s",sql_query.lastError());
        return;
    }
    else
    {

        if(sql_query.next())
        {
            int count = sql_query.value(0).toInt();
//            qDebug("count %d ",count);
            if(count < 1)bHaveTable = false;
        }
    }


    if(bHaveTable == false)
    {
        if(!sql_query.exec("create table recorddata(id INTEGER primary key AUTOINCREMENT,recordid BIGINT, groupid INTEGER,"
                           "vehid TEXT)"))
        {
            qDebug() << "Error: Fail to create table."<< sql_query.lastError();
            return;
        }
        if(!sql_query.exec("CREATE INDEX index_vehid_rec ON recorddata (vehid)"))
        {
            qDebug() << "Error: Fail to create index_vehid."<< sql_query.lastError();
            return;
        }

        if(!sql_query.exec("CREATE INDEX index_groupid_rec ON recorddata (groupid)"))
        {
            qDebug() << "Error: Fail to create index_groupid."<< sql_query.lastError();
            return;
        }


        qDebug("Create Table recorddata successfully.");
    }

    mbSQL = true;
}

void groupdb::run()
{

    OpenDataBase();
    //建立并打开数据库


    if(mbSQL == false)
    {
        qDebug("SQL not OK. so not write data to database.");
        return;
    }

    std::vector<iv::groupdbmsg> xvectordbmsg;
    qint64 nLastWrite = QDateTime::currentMSecsSinceEpoch();
    qint64 nWriteInterval = 1000;
    qint64 nLastCheckRecVector = QDateTime::currentMSecsSinceEpoch();
    qint64 nCheckRecInterval = 3000;

    while(!QThread::isInterruptionRequested())
    {
       qint64 nNow = QDateTime::currentMSecsSinceEpoch();
       if((nNow-nLastCheckRecVector) >= nCheckRecInterval)
       {
           nLastCheckRecVector = nNow;
           CheckRecID();
       }
        mMutexmsg.lock();
        if(mvectordbmsg.size() > 0)
        {
            unsigned int i;
            for(i=0;i<mvectordbmsg.size();i++)
            {
                xvectordbmsg.push_back(mvectordbmsg[i]);
            }
            mvectordbmsg.clear();
        }
        mMutexmsg.unlock();

        if(((xvectordbmsg.size()>10000)||((nNow-nLastWrite)>nWriteInterval))&&(xvectordbmsg.size()>0))
        {
            nLastWrite = nNow;
            QTime xTime;
            xTime.start();
            unsigned int i;
            for(i=0;i<xvectordbmsg.size();i++)
            {

                xvectordbmsg.at(i).mrecid = GetRecID(xvectordbmsg[i].mstrvehid,
                                                     xvectordbmsg[i].mgroupid);
            }
            mdatabase.transaction();


            for(i=0;i<xvectordbmsg.size();i++)
            {
                QSqlQuery query;

                char strsen[1000];
                snprintf(strsen,1000,"INSERT INTO groupdata(vehid,recordid,recvtime,msgtime,groupid,intragroupid,vehdata)"
                         "VALUES(\"%s\",%lld, %lld, %lld,%d,%d,:vehdata)",
                                             xvectordbmsg[i].mstrvehid.data(),xvectordbmsg[i].mrecid,xvectordbmsg[i].mrecvtime,
                         xvectordbmsg[i].mmsgtime,xvectordbmsg[i].mgroupid,xvectordbmsg[i].mintragroupid);
                query.prepare(strsen);
  //              qDebug(strsen);
                query.bindValue(":vehdata", xvectordbmsg[i].mba);
//                query.bindValue(":tracedata", batrace);
                query.exec();
            }
            mdatabase.commit();
            xvectordbmsg.clear();
//            qDebug("transaction time :%d",xTime.elapsed());
        }
        else
        {
            mqueryWaitMutex.lock();
            mwc_query.wait(&mqueryWaitMutex,50);
            mqueryWaitMutex.unlock();

//            msleep(50);
        }

        if(mql_bUpdate)
        {
            ExecQueryList();
            mql_wc.wakeAll();
        }

        if(mqd_bUpdate)
        {
            ExecQueryData();
            mqd_wc.wakeAll();
        }
//        msleep(1000);

    }

    mdatabase.close();
}

int groupdb::addmsg(qint64 recvtime, std::string strvehid, qint64 msgtime, int groupid,
                    int intragroupid, QByteArray & ba)
{
    mMutexmsg.lock();
    if(mvectordbmsg.size()> 10000)
    {
        qDebug("groupdb::addmsg msg buffer vector > 10000 , so not add.");
        mMutexmsg.unlock();
        return -1;
    }
    mMutexmsg.unlock();
    mMutexmsg.lock();
    iv::groupdbmsg xmsg;
    xmsg.mgroupid = groupid;
    xmsg.mintragroupid = intragroupid;
    xmsg.mmsgtime = msgtime;
    xmsg.mrecvtime = recvtime;
    xmsg.mstrvehid = strvehid;
    xmsg.mba = ba;
    mvectordbmsg.push_back(xmsg);
    mMutexmsg.unlock();

    return 0;

}

qint64 groupdb::GetRecID(std::string strvehid,int groupid)
{
    qint64 nrecid = 0;
    bool bFind = false;
    iv::recid xrec;
    mMutexrec.lock();
    unsigned int i;
    for(i=0;i<mvectorrecid.size();i++)
    {
        if(mvectorrecid[i].mstrvehid == strvehid)
        {
            bFind = true;
            nrecid = mvectorrecid[i].mrecid;
            mvectorrecid[i].mnLastUpdateTime = QDateTime::currentMSecsSinceEpoch();
            break;
        }
    }
    if(bFind == false)
    {

        xrec.mgroupid = groupid;
        xrec.mnLastUpdateTime = QDateTime::currentMSecsSinceEpoch();
        xrec.mrecid = QDateTime::currentMSecsSinceEpoch();
        xrec.mstrvehid = strvehid;
        nrecid = xrec.mrecid;
        mvectorrecid.push_back(xrec);
    }
    mMutexrec.unlock();

    if(bFind == false)
    {

        QSqlQuery query;

        char strsen[1000];
        snprintf(strsen,1000,"INSERT INTO recorddata(recordid,groupid,vehid)"
                 " VALUES(%lld, %d,\"%s\")",
                                     xrec.mrecid,xrec.mgroupid,xrec.mstrvehid.data());
        query.exec(strsen);
        qDebug(strsen);
 //       query.exec();

    }

    return nrecid;
}

void groupdb::CheckRecID()
{
    qint64 nEraseTime = 60000; //More than 1 minutes no data. erase.
    if(mvectorrecid.size() == 0)return;
    mMutexrec.lock();
    unsigned int i;
    qint64 nNow = QDateTime::currentMSecsSinceEpoch();
    for(i=0;i<mvectorrecid.size();i++)
    {
        if((nNow - mvectorrecid[i].mnLastUpdateTime)>nEraseTime)
        {
            mvectorrecid.erase(mvectorrecid.begin()+i);
 //           qDebug("erase");
        }
    }
    mMutexrec.unlock();
}

void groupdb::ExecQueryList()
{
    QTime xTime;
    xTime.start();
    mql_Mutexdata.lock();
    QSqlQuery query(mdatabase);
    char strsen[1000];
    snprintf(strsen,1000,"select * from recorddata where((recorddata.recordid >= %lld) &(recorddata.recordid <= %lld) &(recorddata.vehid = \"%s\"))",
             mql_xfrom,mql_xto,mql_strvehid.data());
    query.exec(strsen);
    mql_xvectorrecordtime.clear();
    if(!query.exec(strsen))
    {
        qDebug()<<query.lastError();
    }
    else
    {
        while(query.next())
        {
            int id = query.value(0).toInt();
            qint64 recordid = query.value(1).toLongLong();
            mql_xvectorrecordtime.push_back(recordid);
            std::string strvehid = query.value(3).toString().toStdString();

        }
    }
    mql_bUpdate = false;
    mql_bUpdateRes = true;
    mql_Mutexdata.unlock();
    qDebug("Exec query time is : %d ",xTime.elapsed());
}

int groupdb::GetFilePathDir(QString &strdir)
{
    int nrtn = 0;
    strdir = getenv("HOME");

    strdir = strdir + "/groupdbtmp";
    QDir xDir;

    if(xDir.exists(strdir) == false)
    {
        qDebug("%s is not exist.Create ",strdir.toLatin1().data());
        if(false == xDir.mkdir(strdir))
        {
            nrtn = -1;
        }
    }
    return nrtn;
}

void groupdb::ExecQueryData()
{
    QString strdir;
    if(GetFilePathDir(strdir ) == -1)
    {
        qDebug("Directory Fail.");
        mqd_bUpdateRes = false;
        mqd_nError = -11;
        return;
    }
    QString filename = QString(mqd_strvehid.data()) + "-"
            +QString::number(mqd_nrecordid)+"-"
            +QDateTime::currentDateTime().toString("yyyyMMddhhmmsszzz");

    QFile xFile;
    xFile.setFileName(strdir + "/" + filename);
    if(!xFile.open(QIODevice::ReadWrite))
    {
        qDebug("Open File Fail.");
        mqd_bUpdateRes = false;
        mqd_nError = -12;
        return;
    }


    QTime xTime;
    mqd_filename = filename.toStdString();
    mqd_filesize = 0;
    xTime.start();
    mqd_Mutexdata.lock();
    mqd_filesize = 0;
    QSqlQuery query(mdatabase);
    char strsen[1000];
    snprintf(strsen,1000,"select * from groupdata where((groupdata.recordid = %lld)  &(groupdata.vehid = \"%s\"))",
             mqd_nrecordid,mqd_strvehid.data());
    query.exec(strsen);
    if(!query.exec(strsen))
    {
        qDebug()<<query.lastError();
        mqd_nError = -13;
        mqd_bUpdateRes = false;
    }
    else
    {
        while(query.next())
        {
            QByteArray badata =query.value(7).toByteArray();
            mqd_filesize = mqd_filesize + badata.size();
            xFile.write(badata);
//            int id = query.value(0).toInt();
//            qint64 recordid = query.value(1).toLongLong();
//            mql_xvectorrecordtime.push_back(recordid);
//            std::string strvehid = query.value(3).toString().toStdString();

        }


        mqd_bUpdateRes = true;
    }
    mqd_bUpdate = false;

    xFile.close();
    mqd_Mutexdata.unlock();
    qDebug("Exec querydata time is : %d ",xTime.elapsed());
}

int groupdb::getlist(qint64 xfrom,qint64 xto,std::string &strvehid, std::vector<qint64> &xvectorrecordtime)
{
    if(mbSQL == false)
    {
        return -1;
    }

    int nres = 0;

    mql_Mutex.lock();
    mql_Mutexdata.lock();
    mql_xfrom = xfrom;
    mql_xto = xto;
    mql_bUpdateRes = false;
    mql_bUpdate = true;
    mql_strvehid = strvehid;
    mql_Mutexdata.unlock();

    mwc_query.wakeAll();
    QTime xTime;
    xTime.start();
    mql_waitmutex.lock();
    mql_wc.wait(&mql_waitmutex,300);
    mql_waitmutex.unlock();
    qDebug("query time is %d ",xTime.elapsed());

    if(mql_bUpdateRes == false)
    {
        nres = -2;
    }
    else
    {
        mql_Mutexdata.lock();
        xvectorrecordtime = mql_xvectorrecordtime;
        mql_bUpdateRes = false;
        mql_Mutexdata.unlock();
    }

    mql_Mutex.unlock();

    return nres;

}

int groupdb::getfilepath(qint64 nrecordid, std::string strvehid,std::string & strfilename,int & nfilesize)
{
    if(mbSQL == false)
    {
        return -1;
    }

    int nres = 0;

    mqd_Mutex.lock();
    mqd_Mutexdata.lock();
    mqd_nrecordid = nrecordid;
    mqd_strvehid = strvehid;
    mqd_bUpdateRes = false;
    mqd_bUpdate = true;
    mqd_Mutexdata.unlock();

    mwc_query.wakeAll();
    QTime xTime;
    xTime.start();
    mqd_waitmutex.lock();
    mqd_wc.wait(&mqd_waitmutex,10000);
    mqd_waitmutex.unlock();
    qDebug("query time is %d ",xTime.elapsed());

    if(mqd_bUpdateRes == false)
    {
        if((mqd_nError == -11)||(mqd_nError == -12))
        {
            nres =  -3;
        }
        else
        {
            nres = -2;
        }
    }
    else
    {
        mqd_Mutexdata.lock();
        mqd_bUpdateRes = false;
        strfilename = mqd_filename;
        nfilesize = mqd_filesize;
        mqd_Mutexdata.unlock();
    }

    mqd_Mutex.unlock();

    return nres;
}

int groupdb::GetFileData(std::string strfilename, qint64 nPos, qint64 nFilesize, QByteArray &ba)
{
    QString strpath;
    if(GetFilePathDir(strpath)!= 0)
    {
        qDebug("Directory not exist.");
        return -1; //File Directory can't found.
    }
    strpath = strpath + "/"+ strfilename.data();

    QFile xFile;
    xFile.setFileName(strpath);
    if(!xFile.open(QIODevice::ReadOnly))
    {
        qDebug("Open File Fail.");
        return -2; //File Not Exist
    }
    if(xFile.seek(nPos) == false)
    {
        qDebug("Seek File Fail. pos is %lld",nPos);
        xFile.close();
        return -3;
    }
    ba.clear();
    ba = xFile.read(nFilesize);
    return ba.size();

}