Ticket #6591: mythtv-6591-check_return_value_of_MSqlQuery_exec-programs.patch

File mythtv-6591-check_return_value_of_MSqlQuery_exec-programs.patch, 46.3 KB (added by sphery <mtdean@…>, 12 years ago)

Fixes all occurrences in programs. These are the last occurrences in mythtv. (Haven't checked mythplugins.)

  • programs/mythfrontend/main.cpp

    old new  
    6363#include "mythdirs.h"
    6464#include "mythosdmenueditor.h"
    6565#include "audiopulseutil.h"
     66#include "mythdb.h"
    6667
    6768static ExitPrompter   *exitPopup = NULL;
    6869static MythThemedMenu *menu;
     
    982983    query.prepare("DELETE FROM inuseprograms "
    983984                  "WHERE hostname = :HOSTNAME and recusage = 'player' ;");
    984985    query.bindValue(":HOSTNAME", gContext->GetHostName());
    985     query.exec();
     986    if (!query.exec())
     987        MythDB::DBError("CleanupMyOldInUsePrograms", query);
    986988}
    987989
    988990void ShowUsage(const MythCommandLineParser &cmdlineparser)
     
    12931295        query.prepare("update settings set data='EN' "
    12941296                      "WHERE hostname = :HOSTNAME and value='Language' ;");
    12951297        query.bindValue(":HOSTNAME", gContext->GetHostName());
    1296         query.exec();
     1298        if (!query.exec())
     1299            MythDB::DBError("Updating language", query);
    12971300
    12981301        return FRONTEND_EXIT_OK;
    12991302    }
  • programs/mythfrontend/manualschedule.cpp

    old new  
    207207                  "FROM channel WHERE chanid=:CHANID");
    208208    query.bindValue(":CHANID", p.chanid);
    209209
    210     query.exec();
    211 
    212     if (query.isActive() && query.size())
     210    if (query.exec() && query.isActive() && query.next())
    213211    {
    214         query.next();
    215212        p.chanstr = query.value(1).toString();
    216213        p.chansign = query.value(2).toString();
    217214        p.channame = query.value(3).toString();
  • programs/mythfrontend/playbackbox.cpp

    old new  
    1919
    2020#include "mythdirs.h"
    2121#include "mythcontext.h"
     22#include "mythdb.h"
    2223#include "mythdbcon.h"
    2324#include "mythverbose.h"
    2425#include "programinfo.h"
     
    41794180                           "WHERE recgroup = :RECGROUP ;");
    41804181        query.bindValue(":RECGROUP", m_recGroup);
    41814182
    4182         query.exec();
     4183        if (!query.exec())
     4184            MythDB::DBError("PlaybackBox::SetRecGroupPassword -- delete",
     4185                            query);
    41834186
    41844187        if (!newPassword.isEmpty())
    41854188        {
     
    41894192            query.bindValue(":RECGROUP", m_recGroup);
    41904193            query.bindValue(":PASSWD", newPassword);
    41914194
    4192             query.exec();
     4195            if (!query.exec())
     4196                MythDB::DBError("PlaybackBox::SetRecGroupPassword -- insert",
     4197                                query);
    41934198        }
    41944199    }
    41954200
  • programs/mythcommflag/CommDetector2.cpp

    old new  
    225225            ";");
    226226    query.bindValue(":CHANID", chanid);
    227227    query.bindValue(":STARTTIME", recstartts);
    228     query.exec();
    229     if (query.size() <= 0 || !query.next())
     228    if (!query.exec() || query.size() <= 0 || !query.next())
    230229    {
    231230        MythDB::DBError("Error in CommDetector2::CommDetector2", query);
    232231        return "";
  • programs/mythfrontend/proglist.cpp

    old new  
    1919#include "channelutil.h"
    2020
    2121// mythdb
     22#include "libmythdb/mythdb.h"
    2223#include "libmythdb/mythdbcon.h"
    2324#include "libmythdb/mythverbose.h"
    2425
     
    385386                          "WHERE phrase = :PHRASE AND searchtype = :TYPE;");
    386387            query.bindValue(":PHRASE", qphrase);
    387388            query.bindValue(":TYPE", m_searchType);
    388             query.exec();
     389            if (!query.exec())
     390                MythDB::DBError("ProgLister::updateKeywordInDB -- delete",
     391                                query);
    389392
    390393            m_viewList.removeAll(qphrase);
    391394            m_viewTextList.removeAll(qphrase);
     
    399402                          "VALUES(:PHRASE, :TYPE );");
    400403            query.bindValue(":PHRASE", qphrase);
    401404            query.bindValue(":TYPE", m_searchType);
    402             query.exec();
     405            if (!query.exec())
     406                MythDB::DBError("ProgLister::updateKeywordInDB -- replace",
     407                                query);
    403408
    404409            m_viewList.append(qphrase);
    405410            m_viewTextList.append(qphrase);
     
    739744                  "WHERE chanid = :CHANID AND starttime = :STARTTIME ;");
    740745    query.bindValue(":CHANID", pi->chanid);
    741746    query.bindValue(":STARTTIME", pi->startts.toString(Qt::ISODate));
    742     query.exec();
     747    if (!query.exec())
     748        MythDB::DBError("ProgLister::doDeleteOldRecorded", query);
    743749    ScheduledRecording::signalChange(0);
    744750}
    745751
     
    807813                      "WHERE program.endtime > :PGILSTART "
    808814                      "GROUP BY g1.genre, g2.genre;");
    809815        query.bindValue(":PGILSTART", startstr);
    810         query.exec();
    811816
    812         if (query.isActive() && query.size())
     817        if (query.exec() && query.isActive() && query.size())
    813818        {
    814819            QString lastGenre1;
    815820
     
    843848                          "WHERE program.endtime > :PGILSTART "
    844849                          "GROUP BY category;");
    845850            query.bindValue(":PGILSTART", startstr);
    846             query.exec();
    847851
    848             if (query.isActive() && query.size())
     852            if (query.exec() && query.isActive())
    849853            {
    850854                while (query.next())
    851855                {
     
    871875        query.prepare("SELECT phrase FROM keyword "
    872876                      "WHERE searchtype = :SEARCHTYPE;");
    873877        query.bindValue(":SEARCHTYPE", m_searchType);
    874         query.exec();
    875878
    876         if (query.isActive() && query.size())
     879        if (query.exec() && query.isActive())
    877880        {
    878881            while (query.next())
    879882            {
     
    898901                              "VALUES(:VIEW, :SEARCHTYPE );");
    899902                query.bindValue(":VIEW", qphrase);
    900903                query.bindValue(":SEARCHTYPE", m_searchType);
    901                 query.exec();
     904                if (!query.exec())
     905                    MythDB::DBError("ProgLister::fillViewList -- "
     906                                    "replace keyword", query);
    902907
    903908                m_viewList << qphrase;
    904909                m_viewTextList << qphrase;
     
    10001005        query.prepare("SELECT title FROM record "
    10011006                      "WHERE recordid = :RECORDID");
    10021007        query.bindValue(":RECORDID", view);
    1003         query.exec();
    10041008
    1005         if (query.isActive() && query.size())
     1009        if (query.exec() && query.isActive() && query.next())
    10061010        {
    1007             if (query.next())
    1008             {
    1009                 QString title = query.value(0).toString();
    1010                 title = query.value(0).toString();
    1011                 m_viewList << view;
    1012                 m_viewTextList << title;
    1013             }
     1011            QString title = query.value(0).toString();
     1012            title = query.value(0).toString();
     1013            m_viewList << view;
     1014            m_viewTextList << title;
    10141015        }
    10151016    }
    10161017    else if (m_type == plStoredSearch) // stored searches
     
    10181019        MSqlQuery query(MSqlQuery::InitCon());
    10191020        query.prepare("SELECT rulename FROM customexample "
    10201021                      "WHERE search > 0 ORDER BY rulename;");
    1021         query.exec();
    10221022
    1023         if (query.isActive() && query.size())
     1023        if (query.exec() && query.isActive())
    10241024        {
    10251025            while (query.next())
    10261026            {
     
    13171317        query.prepare("SELECT fromclause, whereclause FROM customexample "
    13181318                      "WHERE rulename = :RULENAME;");
    13191319        query.bindValue(":RULENAME", qphrase);
    1320         query.exec();
    13211320
    1322         if (query.isActive() && query.size())
     1321        if (query.exec() && query.isActive() && query.next())
    13231322        {
    1324             query.next();
    13251323            fromc  = query.value(0).toString();
    13261324            wherec = query.value(1).toString();
    13271325
     
    16081606                    MSqlQuery query(MSqlQuery::InitCon());
    16091607                    query.prepare("DELETE FROM oldrecorded WHERE title = :TITLE ;");
    16101608                    query.bindValue(":TITLE", pi->title);
    1611                     query.exec();
     1609                    if (!query.exec())
     1610                        MythDB::DBError("ProgLister::customEvent -- delete",
     1611                                        query);
    16121612
    16131613                    ScheduledRecording::signalChange(0);
    16141614                    fillItemList(false);
     
    17771777                  "WHERE phrase = :PHRASE AND searchtype = :TYPE;");
    17781778    query.bindValue(":PHRASE", qphrase);
    17791779    query.bindValue(":TYPE", m_searchType);
    1780     query.exec();
     1780    if (!query.exec())
     1781        MythDB::DBError("PhrasePopup::deleteClicked", query);
    17811782
    17821783    m_phraseList->RemoveItem(m_phraseList->GetItemCurrent());
    17831784
     
    20522053                  "WHERE phrase = :PHRASE AND searchtype = :TYPE;");
    20532054    query.bindValue(":PHRASE", qphrase);
    20542055    query.bindValue(":TYPE", m_searchType);
    2055     query.exec();
     2056    if (!query.exec())
     2057        MythDB::DBError("PowerSearchPopup::deleteClicked", query);
    20562058
    20572059    m_phraseList->RemoveItem(m_phraseList->GetItemCurrent());
    20582060
     
    22352237    MSqlQuery query(MSqlQuery::InitCon());
    22362238
    22372239    query.prepare("SELECT genre FROM programgenres GROUP BY genre;");
    2238     query.exec();
    22392240
    2240     if (query.isActive() && query.size())
     2241    if (query.exec() && query.isActive() && query.size())
    22412242    {
    22422243        while (query.next())
    22432244        {
  • programs/mythfrontend/statusbox.cpp

    old new  
    387387                query.prepare("UPDATE mythlog SET acknowledged = 1 "
    388388                            "WHERE logid = :LOGID ;");
    389389                query.bindValue(":LOGID", sql);
    390                 query.exec();
     390                if (!query.exec())
     391                    MythDB::DBError("StatusBox::customEvent -- LogAck", query);
    391392                doLogEntries();
    392393            }
    393394        }
     
    399400                query.prepare("UPDATE mythlog SET acknowledged = 1 "
    400401                                "WHERE priority <= :PRIORITY ;");
    401402                query.bindValue(":PRIORITY", m_minLevel);
    402                 query.exec();
     403                if (!query.exec())
     404                    MythDB::DBError("StatusBox::customEvent -- LogAckAll",
     405                                    query);
    403406                doLogEntries();
    404407            }
    405408        }
  • programs/mythshutdown/main.cpp

    old new  
    5757        query.prepare("SELECT data FROM settings WHERE value = :KEY AND "
    5858                      "hostname IS NULL;");
    5959        query.bindValue(":KEY", key);
    60         query.exec();
    61         if (query.isActive() && query.size() > 0)
     60        if (query.exec() && query.isActive() && query.next())
    6261        {
    63             query.next();
    6462            value = query.value(0).toString();
    6563        }
    6664    }
     
    9694    }
    9795
    9896    // does the setting already exist?
    99     query.exec("SELECT * FROM settings "
    100                "WHERE value = 'MythShutdownLock' AND hostname IS NULL;");
     97    if (!query.exec("SELECT * FROM settings "
     98                    "WHERE value = 'MythShutdownLock' AND hostname IS NULL;"))
     99        MythDB::DBError("lockShutdown -- select", query);
    101100
    102101    if (query.size() < 1)
    103102    {
    104103        // add the lock setting
    105         query.exec("INSERT INTO settings (value, data) "
    106                    "VALUES ('MythShutdownLock', '1');");
     104        if (!query.exec("INSERT INTO settings (value, data) "
     105                        "VALUES ('MythShutdownLock', '1');"))
     106            MythDB::DBError("lockShutdown -- insert", query);
    107107    }
    108108    else
    109109    {
    110110        // update the lock setting
    111         query.exec("UPDATE settings SET data = data + 1 "
    112                    "WHERE value = 'MythShutdownLock' AND hostname IS NULL;");
     111        if (!query.exec("UPDATE settings SET data = data + 1 "
     112                        "WHERE value = 'MythShutdownLock' "
     113                        "AND hostname IS NULL;"))
     114            MythDB::DBError("lockShutdown -- update", query);
    113115    }
    114116
    115117    // unlock settings table
    116     query.exec("UNLOCK TABLES;");
     118    if (!query.exec("UNLOCK TABLES;"))
     119        MythDB::DBError("lockShutdown -- unlock", query);
    117120
    118121    return 0;
    119122}
     
    140143    }
    141144
    142145    // does the setting exist?
    143     query.exec("SELECT * FROM settings "
    144                "WHERE value = 'MythShutdownLock' AND hostname IS NULL;");
     146    if (!query.exec("SELECT * FROM settings "
     147                    "WHERE value = 'MythShutdownLock' AND hostname IS NULL;"))
     148        MythDB::DBError("unlockShutdown -- select", query);
    145149
    146150    if (query.size() < 1)
    147151    {
    148152        // add the lock setting
    149         query.exec("INSERT INTO settings (value, data) "
    150                    "VALUES ('MythShutdownLock', '0');");
     153        if (!query.exec("INSERT INTO settings (value, data) "
     154                        "VALUES ('MythShutdownLock', '0');"))
     155            MythDB::DBError("unlockShutdown -- insert", query);
    151156    }
    152157    else
    153158    {
    154159        // update lock setting
    155         query.exec("UPDATE settings SET data = GREATEST(0,  data - 1) "
    156                    "WHERE value = 'MythShutdownLock' AND hostname IS NULL;");
     160        if (!query.exec("UPDATE settings SET data = GREATEST(0,  data - 1) "
     161                        "WHERE value = 'MythShutdownLock' "
     162                        "AND hostname IS NULL;"))
     163            MythDB::DBError("unlockShutdown -- update", query);
    157164    }
    158165
    159166    // unlock table
    160     query.exec("UNLOCK TABLES;");
     167    if (!query.exec("UNLOCK TABLES;"))
     168        MythDB::DBError("unlockShutdown -- unlock", query);
    161169
    162170    // tell the master BE to reset its idle time
    163171    RemoteSendMessage("RESET_IDLETIME");
  • programs/mythfilldatabase/icondata.cpp

    old new  
    288288                        qc.prepare("SELECT COUNT(*) FROM settings "
    289289                                "WHERE value = :STUBNAME");
    290290                        qc.bindValue(":STUBNAME", st);
    291                         qc.exec();
    292                         if (qc.isActive() && qc.size() > 0)
     291                        if (qc.exec() && qc.isActive() && qc.next())
    293292                        {
    294                             qc.first();
    295293                            if (qc.value(0).toInt() != 0)
    296294                            {
    297295                                qr = &su_query;
     
    350348        QDomElement roote = iconmap.createElement(IM_DOC_TAG);
    351349
    352350        MSqlQuery query(MSqlQuery::InitCon());
    353         query.exec("SELECT * FROM callsignnetworkmap ORDER BY callsign;");
    354351
    355         if (query.isActive() && query.size() > 0)
     352        if (query.exec("SELECT * FROM callsignnetworkmap ORDER BY callsign;") &&
     353            query.isActive())
    356354        {
    357355            while (query.next())
    358356            {
     
    374372            }
    375373        }
    376374
    377         query.exec("SELECT * FROM networkiconmap ORDER BY network;");
    378         if (query.isActive() && query.size() > 0)
     375        if (query.exec("SELECT * FROM networkiconmap ORDER BY network;") &&
     376            query.isActive())
    379377        {
    380378            while (query.next())
    381379            {
     
    401399        query.prepare("SELECT value,data FROM settings WHERE value "
    402400                "LIKE :URLMAP");
    403401        query.bindValue(":URLMAP", QString(BASEURLMAP_START) + "%");
    404         query.exec();
    405         if (query.isActive() && query.size() > 0)
     402        if (query.exec() && query.isActive())
    406403        {
    407404            QRegExp baseax("\\.([^\\.]+)$");
    408405            while (query.next())
  • programs/mythbackend/main.cpp

    old new  
    103103        records_without_station.prepare("SELECT record.chanid,"
    104104                " channel.callsign FROM record LEFT JOIN channel"
    105105                " ON record.chanid = channel.chanid WHERE record.station='';");
    106         records_without_station.exec();
    107         if (records_without_station.first())
     106        if (records_without_station.exec() && records_without_station.next())
    108107        {
    109108            MSqlQuery update_record(MSqlQuery::InitCon());
    110109            update_record.prepare("UPDATE record SET station = :CALLSIGN"
  • programs/mythfilldatabase/main.cpp

    old new  
    728728                "with multiple parts.");
    729729
    730730        MSqlQuery sel(MSqlQuery::InitCon());
    731         sel.exec("SELECT DISTINCT programid, partnumber, parttotal "
    732                  "FROM program WHERE partnumber > 0 AND parttotal > 0 AND "
    733                  "programid LIKE '%0000'");
    734 
    735         if (sel.isActive() && sel.size() > 0)
     731        if (sel.exec("SELECT DISTINCT programid, partnumber, parttotal "
     732                     "FROM program WHERE partnumber > 0 AND parttotal > 0 AND "
     733                     "programid LIKE '%0000'") &&
     734            sel.isActive())
    736735        {
    737736            MSqlQuery repl(MSqlQuery::InitCon());
    738737
     
    814813    if (grab_data)
    815814    {
    816815        MSqlQuery updt(MSqlQuery::InitCon());
    817         updt.exec("UPDATE program SET first = 0, last = 0;");
     816        if (!updt.exec("UPDATE program SET first = 0, last = 0;"))
     817            MythDB::DBError("Clearing first and last showings", updt);
    818818
    819819        VERBOSE(VB_GENERAL, "Marking episode first showings.");
    820820
    821821        MSqlQuery query(MSqlQuery::InitCon());
    822         query.exec("SELECT MIN(starttime),programid FROM program "
    823                    "WHERE programid > '' GROUP BY programid;");
    824 
    825         if (query.isActive() && query.size() > 0)
     822        if (query.exec("SELECT MIN(starttime),programid FROM program "
     823                   "WHERE programid > '' GROUP BY programid;") &&
     824            query.isActive())
    826825        {
    827826            while(query.next())
    828827            {
     
    831830                             "  AND programid = :PROGRAMID;");
    832831                updt.bindValue(":STARTTIME", query.value(0).toDateTime());
    833832                updt.bindValue(":PROGRAMID", query.value(1).toString());
    834                 updt.exec();
     833                if (!updt.exec())
     834                    MythDB::DBError("Marking first showings by id", updt);
    835835            }
    836836        }
    837837        int found = query.size();
    838838
    839         query.exec("SELECT MIN(starttime),title,subtitle,description "
    840                    "FROM program WHERE programid = '' "
    841                    "GROUP BY title,subtitle,description;");
    842 
    843         if (query.isActive() && query.size() > 0)
     839        if (query.exec("SELECT MIN(starttime),title,subtitle,description "
     840                       "FROM program WHERE programid = '' "
     841                       "GROUP BY title,subtitle,description;") &&
     842            query.isActive())
    844843        {
    845844            while(query.next())
    846845            {
     
    853852                updt.bindValue(":TITLE", query.value(1).toString());
    854853                updt.bindValue(":SUBTITLE", query.value(2).toString());
    855854                updt.bindValue(":DESCRIPTION", query.value(3).toString());
    856                 updt.exec();
     855                if (!updt.exec())
     856                    MythDB::DBError("Marking first showings", updt);
    857857            }
    858858        }
    859859        found += query.size();
     
    861861
    862862        VERBOSE(VB_GENERAL, "Marking episode last showings.");
    863863
    864         query.exec("SELECT MAX(starttime),programid FROM program "
    865                    "WHERE programid > '' GROUP BY programid;");
    866 
    867         if (query.isActive() && query.size() > 0)
     864        if (query.exec("SELECT MAX(starttime),programid FROM program "
     865                       "WHERE programid > '' GROUP BY programid;") &&
     866            query.isActive())
    868867        {
    869868            while(query.next())
    870869            {
     
    873872                             "  AND programid = :PROGRAMID;");
    874873                updt.bindValue(":STARTTIME", query.value(0).toDateTime());
    875874                updt.bindValue(":PROGRAMID", query.value(1).toString());
    876                 updt.exec();
     875                if (!updt.exec())
     876                    MythDB::DBError("Marking last showings by id", updt);
    877877            }
    878878        }
    879879        found = query.size();
    880880
    881         query.exec("SELECT MAX(starttime),title,subtitle,description "
    882                    "FROM program WHERE programid = '' "
    883                    "GROUP BY title,subtitle,description;");
    884 
    885         if (query.isActive() && query.size() > 0)
     881        if (query.exec("SELECT MAX(starttime),title,subtitle,description "
     882                       "FROM program WHERE programid = '' "
     883                       "GROUP BY title,subtitle,description;") &&
     884            query.isActive())
    886885        {
    887886            while(query.next())
    888887            {
     
    895894                updt.bindValue(":TITLE", query.value(1).toString());
    896895                updt.bindValue(":SUBTITLE", query.value(2).toString());
    897896                updt.bindValue(":DESCRIPTION", query.value(3).toString());
    898                 updt.exec();
     897                if (!updt.exec())
     898                    MythDB::DBError("Marking last showings", updt);
    899899            }
    900900        }
    901901        found += query.size();
     
    905905    if (1) // limit MSqlQuery's lifetime
    906906    {
    907907        MSqlQuery query(MSqlQuery::InitCon());
    908         query.exec( "SELECT count(previouslyshown) FROM program WHERE previouslyshown = 1;");
    909         if (query.isActive() && query.size() > 0)
     908        if (query.exec( "SELECT count(previouslyshown) "
     909                        "FROM program WHERE previouslyshown = 1;") &&
     910            query.isActive() && query.next())
    910911        {
    911             query.next();
    912912            if (query.value(0).toInt() != 0)
    913                 query.exec("UPDATE settings SET data = '1' WHERE value = 'HaveRepeats';");
     913                if (!query.exec("UPDATE settings SET data = '1' "
     914                                "WHERE value = 'HaveRepeats';"))
     915                    MythDB::DBError("Setting HaveRepeats", query);
    914916            else
    915                 query.exec("UPDATE settings SET data = '0' WHERE value = 'HaveRepeats';");
     917                if (!query.exec("UPDATE settings SET data = '0' "
     918                                "WHERE value = 'HaveRepeats';"))
     919                    MythDB::DBError("Clearing HaveRepeats", query);
    916920        }
    917921    }
    918922
  • programs/mythbackend/mainserver.cpp

    old new  
    17091709                  "WHERE chanid = :CHANID AND starttime = :STARTTIME;");
    17101710    query.bindValue(":CHANID", ds->chanid);
    17111711    query.bindValue(":STARTTIME", ds->recstartts);
    1712     query.exec();
    17131712
    1714     if (!query.isActive())
     1713    if (!query.exec() || !query.isActive())
    17151714    {
    17161715        MythDB::DBError("Recorded program delete recordedmarkup", query);
    17171716        gContext->LogEntry("mythbackend", LP_ERROR, "Delete Recording",
     
    17231722                  "WHERE chanid = :CHANID AND starttime = :STARTTIME;");
    17241723    query.bindValue(":CHANID", ds->chanid);
    17251724    query.bindValue(":STARTTIME", ds->recstartts);
    1726     query.exec();
    17271725
    1728     if (!query.isActive())
     1726    if (!query.exec() || !query.isActive())
    17291727    {
    17301728        MythDB::DBError("Recorded program delete recordedseek", query);
    17311729        gContext->LogEntry("mythbackend", LP_ERROR, "Delete Recording",
     
    25632561                }
    25642562                query.prepare("DELETE FROM program WHERE manualid = :RECID;");
    25652563                query.bindValue(":RECID", recordid);
    2566                 query.exec();
     2564                if (!query.exec())
     2565                    MythDB::DBError("MainServer::HandleGetPendingRecordings "
     2566                                    "- delete", query);
    25672567            }
    25682568        }
    25692569    }
  • programs/mythbackend/scheduler.cpp

    old new  
    382382    MSqlQuery query(dbConn);
    383383    QString thequery;
    384384    QString where = "";
     385    bool ok;
    385386
    386387    // This will cause our temp copy of recordmatch to be empty
    387388    if (recordid == -1)
     
    392393
    393394    query.prepare(thequery);
    394395    recordmatchLock.lock();
    395     query.exec();
     396    ok = query.exec();
    396397    recordmatchLock.unlock();
    397     if (!query.isActive())
     398    if (!ok || !query.isActive())
    398399    {
    399400        MythDB::DBError("FillRecordListFromDB", query);
    400401        return;
     
    402403
    403404    thequery = "ALTER TABLE recordmatch ADD INDEX (recordid);";
    404405    query.prepare(thequery);
    405     query.exec();
    406     if (!query.isActive())
     406    if (!query.exec() || !query.isActive())
    407407    {
    408408        MythDB::DBError("FillRecordListFromDB", query);
    409409        return;
     
    423423
    424424    MSqlQuery queryDrop(dbConn);
    425425    queryDrop.prepare("DROP TABLE recordmatch;");
    426     queryDrop.exec();
    427     if (!queryDrop.isActive())
     426    if (!queryDrop.exec() || !queryDrop.isActive())
    428427    {
    429428        MythDB::DBError("FillRecordListFromDB", queryDrop);
    430429        return;
     
    13511350                subquery.bindValue(":RECORDID", recid);
    13521351                subquery.bindValue(":NEXTREC", nextRecMap[recid]);
    13531352            }
    1354             subquery.exec();
    1355             if (!subquery.isActive())
     1353            if (!subquery.exec() || !subquery.isActive())
    13561354                MythDB::DBError("Update next_record", subquery);
    13571355            else
    13581356                VERBOSE(VB_SCHEDULE, LOC +
     
    15661564                  "  WHERE recstatus = :RSRECORDING");
    15671565    query.bindValue(":RSABORTED", rsAborted);
    15681566    query.bindValue(":RSRECORDING", rsRecording);
    1569     query.exec();
    1570     if (!query.isActive())
     1567    if (!query.exec() || !query.isActive())
    15711568        MythDB::DBError("UpdateAborted", query);
    15721569
    15731570    // wait for slaves to connect
     
    22942291    query.prepare("SELECT DISTINCT hostname, recusage FROM inuseprograms "
    22952292                    "WHERE lastupdatetime > :ONEHOURAGO ;");
    22962293    query.bindValue(":ONEHOURAGO", oneHourAgo);
    2297     if (query.exec() && query.isActive() && query.size() > 0)
     2294    if (query.exec() && query.isActive())
    22982295    {
    22992296        while(query.next()) {
    23002297            SlavesInUse << query.value(0).toString();
     
    24682465                  " enddate,endtime "
    24692466                  "FROM %1 WHERE recordid = :RECORDID").arg(recordTable));
    24702467    query.bindValue(":RECORDID", recordid);
    2471     query.exec();
    2472     if (!query.isActive() || query.size() != 1)
     2468    if (!query.exec() || !query.isActive() || query.size() != 1)
    24732469    {
    24742470        MythDB::DBError("UpdateManuals", query);
    24752471        return;
     
    24872483    query.prepare("SELECT chanid from channel "
    24882484                  "WHERE callsign = :STATION");
    24892485    query.bindValue(":STATION", station);
    2490     query.exec();
    2491     if (!query.isActive())
     2486    if (!query.exec() || !query.isActive())
    24922487    {
    24932488        MythDB::DBError("UpdateManuals", query);
    24942489        return;
     
    25512546            query.bindValue(":TITLE", title);
    25522547            query.bindValue(":SUBTITLE", startdt.toString());
    25532548            query.bindValue(":RECORDID", recordid);
    2554             query.exec();
    2555             if (!query.isActive())
     2549            if (!query.exec() || !query.isActive())
    25562550            {
    25572551                MythDB::DBError("UpdateManuals", query);
    25582552                return;
     
    27032697        query.bindValue(":RECORDID", recordid);
    27042698    }
    27052699
    2706     query.exec();
    2707     if (!query.isActive())
     2700    if (!query.exec() || !query.isActive())
    27082701    {
    27092702        MythDB::DBError("UpdateMatches", query);
    27102703        return;
     
    27172710        query.prepare("DELETE FROM program WHERE manualid = :RECORDID");
    27182711        query.bindValue(":RECORDID", recordid);
    27192712    }
    2720     query.exec();
    2721     if (!query.isActive())
     2713    if (!query.exec() || !query.isActive())
    27222714    {
    27232715        MythDB::DBError("UpdateMatches", query);
    27242716        return;
     
    27282720    query.prepare("SELECT NULL from record "
    27292721                  "WHERE type = :FINDONE AND findid <= 0;");
    27302722    query.bindValue(":FINDONE", kFindOneRecord);
    2731     query.exec();
    2732     if (!query.isActive())
     2723    if (!query.exec() || !query.isActive())
    27332724    {
    27342725        MythDB::DBError("UpdateMatches", query);
    27352726        return;
     
    27422733                      "WHERE type = :FINDONE AND findid <= 0;");
    27432734        query.bindValue(":FINDID", findtoday);
    27442735        query.bindValue(":FINDONE", kFindOneRecord);
    2745         query.exec();
     2736        if (!query.exec())
     2737            MythDB::DBError("UpdateMatches", query);
    27462738    }
    27472739
    27482740    int clause;
     
    28312823                result.bindValue(it.key(), it.value());
    28322824        }
    28332825
    2834         result.exec();
     2826        bool ok = result.exec();
    28352827        gettimeofday(&dbend, NULL);
    28362828
    2837         if (!result.isActive())
     2829        if (!ok || !result.isActive())
    28382830        {
    28392831            MythDB::DBError("UpdateMatches3", result);
    28402832            continue;
     
    28732865    MSqlQuery rlist(dbConn);
    28742866    rlist.prepare(QString("SELECT recordid,title,maxepisodes,maxnewest FROM %1;").arg(recordTable));
    28752867
    2876     rlist.exec();
    2877 
    2878     if (!rlist.isActive())
     2868    if (!rlist.exec() || !rlist.isActive())
    28792869    {
    28802870        MythDB::DBError("CheckTooMany", rlist);
    28812871        return;
     
    29412931        schedTmpRecord = "sched_temp_record";
    29422932
    29432933        result.prepare("DROP TABLE IF EXISTS sched_temp_record;");
    2944         result.exec();
    29452934
    2946         if (!result.isActive())
     2935        if (!result.exec() || !result.isActive())
    29472936        {
    29482937            MythDB::DBError("Dropping sched_temp_record table", result);
    29492938            return;
     
    29512940
    29522941        result.prepare("CREATE TEMPORARY TABLE sched_temp_record "
    29532942                           "LIKE record;");
    2954         result.exec();
    29552943
    2956         if (!result.isActive())
     2944        if (!result.exec() || !result.isActive())
    29572945        {
    29582946            MythDB::DBError("Creating sched_temp_record table",
    29592947                                 result);
     
    29612949        }
    29622950
    29632951        result.prepare("INSERT sched_temp_record SELECT * from record;");
    2964         result.exec();
    29652952
    2966         if (!result.isActive())
     2953        if (!result.exec() || !result.isActive())
    29672954        {
    29682955            MythDB::DBError("Populating sched_temp_record table",
    29692956                                 result);
     
    29722959    }
    29732960
    29742961    result.prepare("DROP TABLE IF EXISTS sched_temp_recorded;");
    2975     result.exec();
    29762962
    2977     if (!result.isActive())
     2963    if (!result.exec() || !result.isActive())
    29782964    {
    29792965        MythDB::DBError("Dropping sched_temp_recorded table", result);
    29802966        return;
     
    29822968
    29832969    result.prepare("CREATE TEMPORARY TABLE sched_temp_recorded "
    29842970                       "LIKE recorded;");
    2985     result.exec();
    29862971
    2987     if (!result.isActive())
     2972    if (!result.exec() || !result.isActive())
    29882973    {
    29892974        MythDB::DBError("Creating sched_temp_recorded table", result);
    29902975        return;
    29912976    }
    29922977
    29932978    result.prepare("INSERT sched_temp_recorded SELECT * from recorded;");
    2994     result.exec();
    29952979
    2996     if (!result.isActive())
     2980    if (!result.exec() || !result.isActive())
    29972981    {
    29982982        MythDB::DBError("Populating sched_temp_recorded table", result);
    29992983        return;
     
    30012985
    30022986    result.prepare(QString("SELECT recpriority, selectclause FROM %1;")
    30032987                           .arg(priorityTable));
    3004     result.exec();
    30052988
    3006     if (!result.isActive())
     2989    if (!result.exec() || !result.isActive())
    30072990    {
    30082991        MythDB::DBError("Power Priority", result);
    30092992        return;
     
    31643147
    31653148    gettimeofday(&dbstart, NULL);
    31663149    result.prepare(rmquery);
    3167     result.exec();
    3168     if (!result.isActive())
     3150    if (!result.exec() || !result.isActive())
    31693151    {
    31703152        MythDB::DBError("AddNewRecords recordmatch", result);
    31713153        return;
    31723154    }
    31733155    result.prepare(query);
    3174     result.exec();
    3175     if (!result.isActive())
     3156    if (!result.exec() || !result.isActive())
    31763157    {
    31773158        MythDB::DBError("AddNewRecords", result);
    31783159        return;
     
    33533334    if (schedTmpRecord == "sched_temp_record")
    33543335    {
    33553336        result.prepare("DROP TABLE IF EXISTS sched_temp_record;");
    3356         result.exec();
     3337        if (!result.exec())
     3338            MythDB::DBError("AddNewRecords sched_temp_record", query);
    33573339    }
    33583340
    33593341    result.prepare("DROP TABLE IF EXISTS sched_temp_recorded;");
    3360     result.exec();
     3342    if (!result.exec())
     3343        MythDB::DBError("AddNewRecords drop table", query);
    33613344}
    33623345
    33633346void Scheduler::AddNotListed(void) {
     
    33933376    gettimeofday(&dbstart, NULL);
    33943377    MSqlQuery result(dbConn);
    33953378    result.prepare(query);
    3396     result.exec();
     3379    bool ok = result.exec();
    33973380    gettimeofday(&dbend, NULL);
    33983381
    3399     if (!result.isActive())
     3382    if (!ok || !result.isActive())
    34003383    {
    34013384        MythDB::DBError("AddNotListed", result);
    34023385        return;
     
    35113494
    35123495    MSqlQuery result(MSqlQuery::InitCon());
    35133496    result.prepare(query);
    3514     result.exec();
    35153497
    3516     if (!result.isActive())
     3498    if (!result.exec() || !result.isActive())
    35173499    {
    35183500        MythDB::DBError("findAllScheduledPrograms", result);
    35193501        return;
  • programs/mythbackend/housekeeper.cpp

    old new  
    100100            result.prepare("INSERT INTO housekeeping(tag,lastrun) "
    101101                           "values(:TAG ,now());");
    102102            result.bindValue(":TAG", dbTag);
    103             result.exec();
     103            if (!result.exec())
     104                MythDB::DBError("HouseKeeper::wantToRun -- insert", result);
    104105
    105106            runOK = true;
    106107        }
     
    116117    {
    117118        result.prepare("DELETE FROM housekeeping WHERE tag = :TAG ;");
    118119        result.bindValue(":TAG", dbTag);
    119         result.exec();
     120        if (!result.exec())
     121            MythDB::DBError("HouseKeeper::updateLastrun -- delete", result);
    120122
    121123        result.prepare("INSERT INTO housekeeping(tag,lastrun) "
    122124                       "values(:TAG ,now()) ;");
    123125        result.bindValue(":TAG", dbTag);
    124         result.exec();
     126        if (!result.exec())
     127            MythDB::DBError("HouseKeeper::updateLastrun -- insert", result);
    125128    }
    126129}
    127130
     
    285288        result.prepare("DELETE FROM mythlog WHERE "
    286289                       "acknowledged=1 and logdate < :DAYS ;");
    287290        result.bindValue(":DAYS", days);
    288         result.exec();
     291        if (!result.exec())
     292            MythDB::DBError("HouseKeeper::flushLogs -- delete acknowledged",
     293                            result);
    289294
    290295        result.prepare("DELETE FROM mythlog WHERE logdate< :MAX ;");
    291296        result.bindValue(":MAX", max);
    292         result.exec();
     297        if (!result.exec())
     298            MythDB::DBError("HouseKeeper::flushLogs -- delete old",
     299                            result);
    293300    }
    294301}
    295302
     
    369376                  "WHERE hostname = :HOSTNAME AND "
    370377                    "( recusage = 'recorder' OR recusage LIKE 'Unknown %' );");
    371378    query.bindValue(":HOSTNAME", gContext->GetHostName());
    372     query.exec();
     379    if (!query.exec())
     380        MythDB::DBError("HouseKeeper::CleanupMyOldRecordings", query);
    373381}
    374382
    375383void HouseKeeper::CleanupAllOldInUsePrograms(void)
     
    380388    query.prepare("DELETE FROM inuseprograms "
    381389                  "WHERE lastupdatetime < :FOURHOURSAGO ;");
    382390    query.bindValue(":FOURHOURSAGO", fourHoursAgo);
    383     query.exec();
     391    if (!query.exec())
     392        MythDB::DBError("HouseKeeper::CleanupAllOldInUsePrograms", query);
    384393}
    385394
    386395void HouseKeeper::CleanupOrphanedLivetvChains(void)
     
    416425                      .arg(keepChains);
    417426    }
    418427    deleteQuery.prepare(msg);
    419     deleteQuery.exec();
     428    if (!deleteQuery.exec())
     429        MythDB::DBError("HouseKeeper Cleaning TVChain Table", deleteQuery);
    420430}
    421431
    422432void HouseKeeper::CleanupRecordedTables(void)
     
    494504        {
    495505            deleteQuery.bindValue(":CHANID", query.value(0).toString());
    496506            deleteQuery.bindValue(":STARTTIME", query.value(1).toString());
    497             deleteQuery.exec();
     507            if (!deleteQuery.exec())
     508                MythDB::DBError("HouseKeeper Cleaning Recorded Tables",
     509                                deleteQuery);
    498510        }
    499511
    500512        tableIndex++;
     
    517529
    518530    query.prepare("DELETE FROM oldprogram WHERE airdate < "
    519531                  "DATE_SUB(CURRENT_DATE, INTERVAL 320 DAY);");
    520     query.exec();
     532    if (!query.exec())
     533        MythDB::DBError("HouseKeeper Cleaning Program Listings", query);
    521534
    522535    query.prepare("REPLACE INTO oldprogram (oldtitle,airdate) "
    523536                  "SELECT title,starttime FROM program "
    524537                  "WHERE starttime < NOW() AND manualid = 0 "
    525538                  "GROUP BY title;");
    526     query.exec();
     539    if (!query.exec())
     540        MythDB::DBError("HouseKeeper Cleaning Program Listings", query);
    527541
    528542    query.prepare("DELETE FROM program WHERE starttime <= "
    529543                  "DATE_SUB(CURRENT_DATE, INTERVAL :OFFSET DAY);");
    530544    query.bindValue(":OFFSET", offset);
    531     query.exec();
     545    if (!query.exec())
     546        MythDB::DBError("HouseKeeper Cleaning Program Listings", query);
    532547
    533548    query.prepare("DELETE FROM programrating WHERE starttime <= "
    534549                  "DATE_SUB(CURRENT_DATE, INTERVAL :OFFSET DAY);");
    535550    query.bindValue(":OFFSET", offset);
    536     query.exec();
     551    if (!query.exec())
     552        MythDB::DBError("HouseKeeper Cleaning Program Listings", query);
    537553
    538554    query.prepare("DELETE FROM programgenres WHERE starttime <= "
    539555                  "DATE_SUB(CURRENT_DATE, INTERVAL :OFFSET DAY);");
    540556    query.bindValue(":OFFSET", offset);
    541     query.exec();
     557    if (!query.exec())
     558        MythDB::DBError("HouseKeeper Cleaning Program Listings", query);
    542559
    543560    query.prepare("DELETE FROM credits WHERE starttime <= "
    544561                  "DATE_SUB(CURRENT_DATE, INTERVAL :OFFSET DAY);");
    545562    query.bindValue(":OFFSET", offset);
    546     query.exec();
     563    if (!query.exec())
     564        MythDB::DBError("HouseKeeper Cleaning Program Listings", query);
    547565
    548566    query.prepare("DELETE FROM record WHERE (type = :SINGLE "
    549567                  "OR type = :OVERRIDE OR type = :DONTRECORD) "
     
    551569    query.bindValue(":SINGLE", kSingleRecord);
    552570    query.bindValue(":OVERRIDE", kOverrideRecord);
    553571    query.bindValue(":DONTRECORD", kDontRecord);
    554     query.exec();
     572    if (!query.exec())
     573        MythDB::DBError("HouseKeeper Cleaning Program Listings", query);
    555574
    556575    MSqlQuery findq(MSqlQuery::InitCon());
    557576    findq.prepare("SELECT record.recordid FROM record "
    558577                  "LEFT JOIN oldfind ON oldfind.recordid = record.recordid "
    559578                  "WHERE type = :FINDONE AND oldfind.findid IS NOT NULL;");
    560579    findq.bindValue(":FINDONE", kFindOneRecord);
    561     findq.exec();
    562580
    563     if (findq.isActive() && findq.size() > 0)
     581    if (findq.exec() && findq.isActive())
    564582    {
    565583        while (findq.next())
    566584        {
    567585            query.prepare("DELETE FROM record WHERE recordid = :RECORDID;");
    568586            query.bindValue(":RECORDID", findq.value(0).toInt());
    569             query.exec();
     587            if (!query.exec())
     588                MythDB::DBError("HouseKeeper Cleaning Program Listings", query);
    570589        }
    571590    }
    572591    query.prepare("DELETE FROM oldfind WHERE findid < TO_DAYS(NOW()) - 14;");
    573     query.exec();
     592    if (!query.exec())
     593        MythDB::DBError("HouseKeeper Cleaning Program Listings", query);
    574594
    575595    int cleanOldRecorded = gContext->GetNumSetting( "CleanOldRecorded", 10);
    576596
     
    579599                  "endtime < DATE_SUB(CURRENT_DATE, INTERVAL :CLEAN DAY);");
    580600    query.bindValue(":RECORDED", rsRecorded);
    581601    query.bindValue(":CLEAN", cleanOldRecorded);
    582     query.exec();
     602    if (!query.exec())
     603        MythDB::DBError("HouseKeeper Cleaning Program Listings", query);
    583604
    584605}
    585606
  • programs/mythbackend/backendutil.cpp

    old new  
    1616#include "remoteutil.h"
    1717
    1818#include "mythcontext.h"
     19#include "mythdb.h"
    1920#include "mythdbcon.h"
    2021#include "util.h"
    2122#include "decodeencode.h"
     
    9293                          "WHERE groupname = :GROUP "
    9394                          "GROUP BY dirname;");
    9495            query.bindValue(":GROUP", "Default");
    95             query.exec();
     96            if (!query.exec())
     97                MythDB::DBError("BackendQueryDiskSpace", query);
    9698        }
    9799
    98100        QDir checkDir("");
  • programs/mythbackend/upnpcdsvideo.cpp

    old new  
    203203                    "AND parentid = :ROOTID");
    204204
    205205    query.bindValue(":ROOTID", STARTING_VIDEO_OBJECTID);
    206     query.exec();
    207206
    208     if (query.size() > 0)
     207    if (query.exec() && query.next())
    209208    {
    210         query.next();
    211209        nCount = query.value(0).toInt();
    212210    }
    213211
     
    252250            if (query.isConnected())                                                           
    253251            {
    254252                BuildItemQuery( query, mapParams );
    255                 query.exec();
    256    
    257                 if (query.isActive() && query.size() > 0)
     253
     254                if (query.exec() && query.isActive() && query.next())
    258255                {
    259                     if ( query.next() )
    260                     {
    261                         AddItem( pRequest->m_sParentId, pResults, false, query );
    262                         pResults->m_nTotalMatches = 1;
    263                     }
     256                    AddItem( pRequest->m_sParentId, pResults, false, query );
     257                    pResults->m_nTotalMatches = 1;
    264258                }
    265259            }
    266260
     
    366360        //VERBOSE(VB_UPNP, QString("sSQL = %1").arg(sSQL));
    367361        if ( sKey.length() )
    368362            query.bindValue(":KEY", sKey );
    369         query.exec();
    370363
    371         if (query.isActive() && query.size() > 0)
     364        if (query.exec() && query.isActive())
    372365        {
    373366            while(query.next())
    374367                AddItem( pRequest->m_sObjectId, pResults, bAddRef, query );
  • programs/mythtranscode/main.cpp

    old new  
    979979                          "AND starttime = :STARTTIME ");
    980980            query.bindValue(":CHANID", pginfo->chanid);
    981981            query.bindValue(":STARTTIME", pginfo->recstartts);
    982             query.exec();
    983982
    984             if (!query.isActive())
     983            if (!query.exec() || !query.isActive())
    985984                MythDB::DBError("Error in mythtranscode", query);
    986985
    987986            query.prepare("UPDATE recorded "
     
    993992            query.bindValue(":WATCHED", "0");
    994993            query.bindValue(":CHANID", pginfo->chanid);
    995994            query.bindValue(":STARTTIME", pginfo->recstartts);
    996             query.exec();
    997995
    998             if (!query.isActive())
     996            if (!query.exec() || !query.isActive())
    999997                MythDB::DBError("Error in mythtranscode", query);
    1000998
    1001999            pginfo->SetCommFlagged(COMM_FLAG_NOT_FLAGGED);
     
    10151013            query.bindValue(":BOOKMARK", MARK_BOOKMARK);
    10161014            query.bindValue(":CUTLIST_START", MARK_CUT_START);
    10171015            query.bindValue(":CUTLIST_END", MARK_CUT_END);
    1018             query.exec();
    10191016
    1020             if (!query.isActive())
     1017            if (!query.exec() || !query.isActive())
    10211018                MythDB::DBError("Error in mythtranscode", query);
    10221019        }
    10231020
  • programs/mythbackend/upnpmedia.cpp

    old new  
    100100    QString sSQL = "SELECT filename, title, coverfile FROM videometadata";
    101101
    102102    query.prepare  ( sSQL );
    103     query.exec();
    104103
    105     if (query.isActive() && query.size() > 0)
     104    if (query.exec() && query.isActive())
    106105    {
    107106        while(query.next())
    108107        {
     
    166165            query.bindValue(":TITLE", GetTitleName(fPath,fName));
    167166            query.bindValue(":COVERART", GetCoverArt(fPath));
    168167
    169             query.exec();
     168            if (!query.exec())
     169                MythDB::DBError("UPnpMedia::buildFileList", query);
    170170
    171171            itemID = buildFileList(Info.filePath(), 0, itemID, query);
    172172            continue;
     
    209209            query.bindValue(":TITLE", GetTitleName(fPath,fName));
    210210            query.bindValue(":COVERART", GetCoverArt(fPath));
    211211
    212             query.exec();
     212            if (!query.exec())
     213                MythDB::DBError("UPnpMedia::buildFileList", query);
    213214
    214215        }
    215216    }