Ticket #9704: mythtv-0.24-backport_reconnect_fixes.patch

File mythtv-0.24-backport_reconnect_fixes.patch, 29.7 KB (added by sphery, 10 years ago)

Backports 063e45ed23 , 4dfcdb8dd , and 1fb0a77fc from master to 0.24-fixes.

  • mythtv/libs/libmyth/programinfo.cpp

    Backports 063e45ed23 , 4dfcdb8dd , and 1fb0a77fc from master.
    
    Corrects one additional addBindValue() in ProgramInfo::QueryDVDBookmark that no longer exists in master.
    
    
    ---
     mythplugins/mythmusic/mythmusic/smartplaylist.cpp     |    2 	1 +	1 -	0 !
     mythplugins/mythweather/mythweather/weatherSource.cpp |    6 	3 +	3 -	0 !
     mythtv/libs/libmyth/programinfo.cpp                   |   28 	14 +	14 -	0 !
     mythtv/libs/libmythdb/mythdb.cpp                      |    2 	1 +	1 -	0 !
     mythtv/libs/libmythdb/mythdb.h                        |    5 	3 +	2 -	0 !
     mythtv/libs/libmythdb/mythdbcon.cpp                   |  201 	121 +	80 -	0 !
     mythtv/libs/libmythdb/mythdbcon.h                     |   54 	47 +	7 -	0 !
     mythtv/libs/libmythdb/mythversion.h                   |    2 	1 +	1 -	0 !
     mythtv/libs/libmythtv/datadirect.cpp                  |    3 	1 +	2 -	0 !
     mythtv/libs/libmythtv/dbcheck.cpp                     |    8 	4 +	4 -	0 !
     mythtv/programs/mythbackend/httpstatus.cpp            |    9 	3 +	6 -	0 !
     mythtv/programs/mythbackend/main_helpers.cpp          |   12 	5 +	7 -	0 !
     mythtv/programs/mythbackend/mainserver.cpp            |    8 	3 +	5 -	0 !
     mythtv/programs/mythbackend/scheduler.cpp             |    4 	2 +	2 -	0 !
     mythtv/programs/mythfrontend/progfind.cpp             |    2 	1 +	1 -	0 !
     15 files changed, 210 insertions(+), 136 deletions(-)
    
    old new QStringList ProgramInfo::QueryDVDBookmar 
    22162216    {
    22172217        query.prepare(" SELECT title, framenum, audionum, subtitlenum "
    22182218                        " FROM dvdbookmark "
    2219                         " WHERE serialid = ? ");
    2220         query.addBindValue(serialid);
     2219                        " WHERE serialid = :SERIALID ");
     2220        query.bindValue(":SERIALID", serialid);
    22212221
    22222222        if (query.exec() && query.next())
    22232223        {
    QStringList ProgramInfo::QueryDVDBookmar 
    22312231        int days = -(gCoreContext->GetNumSetting("DVDBookmarkDays", 10));
    22322232        QDateTime removedate = mythCurrentDateTime().addDays(days);
    22332233        query.prepare(" DELETE from dvdbookmark "
    2234                         " WHERE timestamp < ? ");
    2235         query.addBindValue(removedate.toString(Qt::ISODate));
     2234                        " WHERE timestamp < :REMOVEDATE ");
     2235        query.bindValue(":REMOVEDATE", removedate.toString(Qt::ISODate));
    22362236
    22372237        if (!query.exec())
    22382238            MythDB::DBError("GetDVDBookmark deleting old entries", query);
    void ProgramInfo::SaveDVDBookmark(const  
    22632263        MythDB::DBError("SetDVDBookmark inserting", query);
    22642264
    22652265    query.prepare(" UPDATE dvdbookmark "
    2266                     " SET title       = ? , "
    2267                     "     audionum    = ? , "
    2268                     "     subtitlenum = ? , "
    2269                     "     framenum    = ? , "
     2266                    " SET title       = :TITLE , "
     2267                    "     audionum    = :AUDIONUM , "
     2268                    "     subtitlenum = :SUBTITLENUM , "
     2269                    "     framenum    = :FRAMENUM , "
    22702270                    "     timestamp   = NOW() "
    2271                     " WHERE serialid = ? ;");
    2272     query.addBindValue(title);
    2273     query.addBindValue(audionum);
    2274     query.addBindValue(subtitlenum);
    2275     query.addBindValue(frame);
    2276     query.addBindValue(serialid);
     2271                    " WHERE serialid = :SERIALID");
     2272    query.bindValue(":TITLE",title);
     2273    query.bindValue(":AUDIONUM",audionum);
     2274    query.bindValue(":SUBTITLENUM",subtitlenum);
     2275    query.bindValue(":FRAMENUM",frame);
     2276    query.bindValue(":SERIALID",serialid);
    22772277
    22782278    if (!query.exec())
    22792279        MythDB::DBError("SetDVDBookmark updating", query);
  • mythtv/libs/libmythdb/mythdb.cpp

    old new QString MythDB::toCommaList(const QMap<Q 
    158158    return str;
    159159}
    160160
    161 void MythDB::DBError(const QString &where, const QSqlQuery& query)
     161void MythDB::DBError(const QString &where, const MSqlQuery& query)
    162162{
    163163    QString str = QString("DB Error (%1):\n").arg(where);
    164164
  • mythtv/libs/libmythdb/mythdb.h

    old new class MDBManager; 
    1414
    1515class MPUBLIC MythDB
    1616{
     17    friend class MSqlQuery;
    1718  public:
    1819    MDBManager *GetDBManager(void);
    1920    Settings *GetOldSettings(void);
    2021
    21     static void DBError(const QString &where, const QSqlQuery &query);
    22     static QString DBErrorMessage(const QSqlError& err);
     22    static void DBError(const QString &where, const MSqlQuery &query);
     23    static QString DBErrorMessage(const QSqlError &err);
    2324
    2425    DatabaseParams GetDatabaseParams(void) const;
    2526    void SetDatabaseParams(const DatabaseParams &params);
  • mythtv/libs/libmythdb/mythdbcon.cpp

    old new  
    1515#include "mythdb.h"
    1616#include "mythverbose.h"
    1717
     18#define DEBUG_RECONNECT 0
     19#if DEBUG_RECONNECT
     20#include <stdlib.h>
     21#endif
     22
    1823static const uint kPurgeTimeout = 60 * 60;
    1924
    2025MSqlDatabase::MSqlDatabase(const QString &name)
    bool MSqlDatabase::OpenDatabase() 
    158163    return connected;
    159164}
    160165
    161 bool MSqlDatabase::KickDatabase()
     166bool MSqlDatabase::KickDatabase(void)
    162167{
    163     // Some explanation is called for.  This exists because the mysql
    164     // driver does not gracefully handle the situation where a TCP
    165     // socketconnection is dropped (for example due to a timeout).  If
    166     // a Unix domain socket connection is lost, the driver
    167     // transparently reestablishes the connection and we don't even
    168     // notice.  However, when this happens with a TCP connection, the
    169     // driver returns an error for the next query to be executed, and
    170     // THEN reestablishes the connection (so the second query succeeds
    171     // with no intervention).
    172     // mdz, 2003/08/11
    173 
    174 
    175     if (m_lastDBKick.secsTo(QDateTime::currentDateTime()) < 30 &&
    176         m_db.isOpen())
    177     {
    178         return true;
    179     }
    180 
    181     QString query("SELECT NULL;");
    182     for (unsigned int i = 0 ; i < 2 ; ++i, usleep(50000))
    183     {
    184         if (m_db.isOpen())
    185         {
    186             QSqlQuery result = m_db.exec(query); // don't convert to MSqlQuery
    187             if (result.isActive())
    188             {
    189                 m_lastDBKick = QDateTime::currentDateTime();
    190                 return true;
    191             }
    192         }
    193 
    194         if (i == 0)
    195         {
    196             m_db.close();
    197             m_db.open();
    198         }
    199         else
    200             VERBOSE(VB_IMPORTANT, MythDB::DBErrorMessage(m_db.lastError()));
    201     }
    202 
    203168    m_lastDBKick = QDateTime::currentDateTime().addSecs(-60);
    204169
    205     return false;
     170    if (!m_db.isOpen())
     171        m_db.open();
     172
     173    return m_db.isOpen();
    206174}
    207175
    208176bool MSqlDatabase::Reconnect()
    MSqlQueryInfo MSqlQuery::DDCon() 
    503471
    504472bool MSqlQuery::exec()
    505473{
     474    if (!m_db)
     475    {
     476        // Database structure's been deleted
     477        return false;
     478    }
     479
     480    if (m_last_prepared_query.isEmpty())
     481    {
     482        VERBOSE(VB_IMPORTANT,
     483            "MSqlQuery::exec(void) called without a prepared query.");
     484        return false;
     485    }
     486
     487#if DEBUG_RECONNECT
     488    if (random() < RAND_MAX / 50)
     489    {
     490        VERBOSE(VB_IMPORTANT,
     491            "MSqlQuery disconnecting DB to test reconnection logic");
     492        m_db->m_db.close();
     493    }
     494#endif
     495
    506496    // Database connection down.  Try to restart it, give up if it's still
    507497    // down
    508     if (!m_db->isOpen() && !m_db->Reconnect())
     498    if (!m_db->isOpen() && !Reconnect())
    509499    {
    510500        VERBOSE(VB_IMPORTANT, "MySQL server disconnected");
    511501        return false;
    bool MSqlQuery::exec() 
    516506    // if the query failed with "MySQL server has gone away"
    517507    // Close and reopen the database connection and retry the query if it
    518508    // connects again
    519     if (!result && QSqlQuery::lastError().number() == 2006 && m_db->Reconnect())
     509    if (!result && QSqlQuery::lastError().number() == 2006 && Reconnect())
    520510        result = QSqlQuery::exec();
    521511
    522512    if (VERBOSE_LEVEL_CHECK(VB_DATABASE))
    bool MSqlQuery::exec() 
    547537
    548538bool MSqlQuery::exec(const QString &query)
    549539{
     540    if (!m_db)
     541    {
     542        // Database structure's been deleted
     543        return false;
     544    }
     545
    550546    // Database connection down.  Try to restart it, give up if it's still
    551547    // down
    552     if (!m_db->isOpen() && !m_db->Reconnect())
     548    if (!m_db->isOpen() && !Reconnect())
    553549    {
    554550        VERBOSE(VB_IMPORTANT, "MySQL server disconnected");
    555551        return false;
    bool MSqlQuery::exec(const QString &quer 
    560556    // if the query failed with "MySQL server has gone away"
    561557    // Close and reopen the database connection and retry the query if it
    562558    // connects again
    563     if (!result && QSqlQuery::lastError().number() == 2006 && m_db->Reconnect())
     559    if (!result && QSqlQuery::lastError().number() == 2006 && Reconnect())
    564560        result = QSqlQuery::exec(query);
    565561
    566562    VERBOSE(VB_DATABASE,
    bool MSqlQuery::exec(const QString &quer 
    573569    return result;
    574570}
    575571
    576 bool MSqlQuery::next()
     572bool MSqlQuery::seekDebug(const char *type, bool result,
     573                          int where, bool relative) const
    577574{
    578     bool result = QSqlQuery::next();
    579 
    580575    if (result && VERBOSE_LEVEL_CHECK(VB_DATABASE|VB_EXTRA))
    581576    {
    582577        QString str;
    583         QSqlRecord record=QSqlQuery::record();
     578        QSqlRecord rec = record();
    584579
    585         for ( long int i = 0; i<record.count(); i++ )
     580        for (long int i = 0; i < rec.count(); i++)
    586581        {
    587582            if (!str.isEmpty())
    588583                str.append(", ");
    589584
    590             str.append(record.fieldName(i) + " = " + value(i).toString());
     585            str.append(rec.fieldName(i) + " = " +
     586                       value(i).toString());
    591587        }
    592588
    593         VERBOSE(VB_DATABASE+VB_EXTRA,
    594                 QString("MSqlQuery::next(%1) Result: \"%2\"")
    595                         .arg(m_db->MSqlDatabase::GetConnectionName())
    596                         .arg(str));
     589        if (QString("seek")==type)
     590        {
     591            VERBOSE(VB_DATABASE+VB_EXTRA,
     592                QString("MSqlQuery::seek(%1,%2,%3) Result: \"%4\"")
     593                .arg(m_db->MSqlDatabase::GetConnectionName())
     594                .arg(where).arg(relative)
     595                .arg(str));
     596        }
     597        else
     598        {
     599            VERBOSE(VB_DATABASE+VB_EXTRA,
     600                QString("MSqlQuery::%1(%2) Result: \"%3\"")
     601                .arg(type).arg(m_db->MSqlDatabase::GetConnectionName())
     602                .arg(str));
     603        }
    597604    }
    598 
    599605    return result;
    600606}
    601607
     608bool MSqlQuery::next(void)
     609{
     610    return seekDebug("next", QSqlQuery::next(), 0, false);
     611}
     612
     613bool MSqlQuery::previous(void)
     614{
     615    return seekDebug("previous", QSqlQuery::previous(), 0, false);
     616}
     617
     618bool MSqlQuery::first(void)
     619{
     620    return seekDebug("first", QSqlQuery::first(), 0, false);
     621}
     622
     623bool MSqlQuery::last(void)
     624{
     625    return seekDebug("last", QSqlQuery::last(), 0, false);
     626}
     627
     628bool MSqlQuery::seek(int where, bool relative)
     629{
     630    return seekDebug("seek", QSqlQuery::seek(where, relative), where, relative);
     631}
     632
    602633bool MSqlQuery::prepare(const QString& query)
    603634{
     635    if (!m_db)
     636    {
     637        // Database structure's been deleted
     638        return false;
     639    }
     640
    604641    m_last_prepared_query = query;
     642
    605643#ifdef DEBUG_QT4_PORT
    606644    if (query.contains(m_testbindings))
    607645    {
    bool MSqlQuery::prepare(const QString& q 
    614652
    615653    // Database connection down.  Try to restart it, give up if it's still
    616654    // down
    617     if (!m_db->isOpen() && !m_db->Reconnect())
     655    if (!m_db)
     656    {
     657       // Database structure has been deleted...
     658        return false;
     659    }
     660
     661    if (!m_db->isOpen() && !Reconnect())
    618662    {
    619663        VERBOSE(VB_IMPORTANT, "MySQL server disconnected");
    620664        return false;
    bool MSqlQuery::prepare(const QString& q 
    625669    // if the prepare failed with "MySQL server has gone away"
    626670    // Close and reopen the database connection and retry the query if it
    627671    // connects again
    628     if (!ok && QSqlQuery::lastError().number() == 2006 && m_db->Reconnect())
     672    if (!ok && QSqlQuery::lastError().number() == 2006 && Reconnect())
    629673        ok = QSqlQuery::prepare(query);
    630674
    631675    if (!ok && !(GetMythDB()->SuppressDBMessages()))
    bool MSqlQuery::testDBConnection() 
    649693    return isOpen;
    650694}
    651695
    652 void MSqlQuery::bindValue (const QString  & placeholder,
    653                            const QVariant & val, QSql::ParamType paramType)
     696void MSqlQuery::bindValue(const QString &placeholder, const QVariant &val)
    654697{
    655698#ifdef DEBUG_QT4_PORT
    656699    // XXX - HACK BEGIN
    void MSqlQuery::bindValue (const QString 
    665708    // XXX - HACK END
    666709#endif
    667710
    668     if (val.type() == QVariant::String && val.isNull())
    669     {
    670         QSqlQuery::bindValue(placeholder, QString(""), paramType);
    671         return;
    672     }
    673     QSqlQuery::bindValue(placeholder, val, paramType);
     711    QSqlQuery::bindValue(placeholder, val, QSql::In);
    674712}
    675713
    676 void MSqlQuery::bindValue(int pos, const QVariant & val,
    677                                    QSql::ParamType  paramType)
     714void MSqlQuery::bindValues(const MSqlBindings &bindings)
    678715{
    679     if (val.type() == QVariant::String && val.isNull())
    680     {
    681         QSqlQuery::bindValue(pos, QString(""), paramType);
    682         return;
    683     }
    684     QSqlQuery::bindValue(pos, val, paramType);
    685 }
    686 
    687 void MSqlQuery::bindValues(MSqlBindings &bindings)
    688 {
    689     MSqlBindings::Iterator it;
     716    MSqlBindings::const_iterator it;
    690717    for (it = bindings.begin(); it != bindings.end(); ++it)
    691718    {
    692719        bindValue(it.key(), it.value());
    QVariant MSqlQuery::lastInsertId() 
    698725    return QSqlQuery::lastInsertId();
    699726}
    700727
     728bool MSqlQuery::Reconnect(void)
     729{
     730    if (!m_db->Reconnect())
     731        return false;
     732    if (!m_last_prepared_query.isEmpty())
     733    {
     734        MSqlBindings tmp = QSqlQuery::boundValues();
     735        if (!prepare(m_last_prepared_query))
     736            return false;
     737        bindValues(tmp);
     738    }
     739    return true;
     740}
     741
    701742void MSqlAddMoreBindings(MSqlBindings &output, MSqlBindings &addfrom)
    702743{
    703744    MSqlBindings::Iterator it;
  • mythtv/libs/libmythdb/mythdbcon.h

    old new  
    22#define MYTHDBCON_H_
    33
    44#include <QSqlDatabase>
     5#include <QSqlRecord>
     6#include <QSqlError>
    57#include <QVariant>
    68#include <QSqlQuery>
    79#include <QRegExp>
     
    1416class QSemaphore;
    1517
    1618/// \brief QSqlDatabase wrapper, used by MSqlQuery. Do not use directly.
    17 class MPUBLIC MSqlDatabase
     19class MSqlDatabase
    1820{
    1921  friend class MDBManager;
    2022  friend class MSqlQuery;
    MPUBLIC void MSqlEscapeAsAQuery(QString  
    101103 *   will crash if closed and reopend - so we never close them and keep them in
    102104 *   a pool.
    103105 */
    104 class MPUBLIC MSqlQuery : public QSqlQuery
     106class MPUBLIC MSqlQuery : private QSqlQuery
    105107{
     108    friend void MSqlEscapeAsAQuery(QString&, MSqlBindings&);
    106109  public:
    107110    /// \brief Get DB connection from pool
    108111    MSqlQuery(const MSqlQueryInfo &qi);
    class MPUBLIC MSqlQuery : public QSqlQue 
    118121    /// \brief Wrap QSqlQuery::next() so we can display the query results
    119122    bool next(void);
    120123
     124    /// \brief Wrap QSqlQuery::previous() so we can display the query results
     125    bool previous(void);
     126
     127    /// \brief Wrap QSqlQuery::first() so we can display the query results
     128    bool first(void);
     129
     130    /// \brief Wrap QSqlQuery::last() so we can display the query results
     131    bool last(void);
     132
     133    /// \brief Wrap QSqlQuery::seek(int,bool)
     134    //         so we can display the query results
     135    bool seek(int, bool relative = false);
     136
    121137    /// \brief Wrap QSqlQuery::exec(const QString &query) so we can display SQL
    122138    bool exec(const QString &query);
    123139
    124140    /// \brief QSqlQuery::prepare() is not thread safe in Qt <= 3.3.2
    125141    bool prepare(const QString &query);
    126142
    127     /// \brief Wrap QSqlQuery::bindValue so we can convert null QStrings to empty QStrings
    128     void bindValue ( const QString & placeholder, const QVariant & val, QSql::ParamType paramType = QSql::In );
    129     /// \brief Wrap QSqlQuery::bindValue so we can convert null QStrings to empty QStrings
    130     void bindValue ( int pos, const QVariant & val, QSql::ParamType paramType = QSql::In );
     143    void bindValue(const QString &placeholder, const QVariant &val);
    131144
    132145    /// \brief Add all the bindings in the passed in bindings
    133     void bindValues(MSqlBindings &bindings);
     146    void bindValues(const MSqlBindings &bindings);
    134147
    135148    /** \brief Return the id of the last inserted row
    136149     *
    class MPUBLIC MSqlQuery : public QSqlQue 
    142155     */
    143156    QVariant lastInsertId();
    144157
     158    /// Reconnects server and re-prepares and re-binds the last prepared
     159    /// query.
     160    bool Reconnect(void);
     161
     162    // Thunks that allow us to make QSqlQuery private
     163    QVariant value(int i) const { return QSqlQuery::value(i); }
     164    QString executedQuery(void) const { return QSqlQuery::executedQuery(); }
     165    QMap<QString, QVariant> boundValues(void) const
     166        { return QSqlQuery::boundValues(); }
     167    QSqlError lastError(void) const { return QSqlQuery::lastError(); }
     168    int size(void) const { return QSqlQuery::size();}
     169    bool isActive(void) const { return  QSqlQuery::isActive(); }
     170    QSqlRecord record(void) const { return QSqlQuery::record(); }
     171    int numRowsAffected() const { return QSqlQuery::numRowsAffected(); }
     172    void setForwardOnly(bool f) { QSqlQuery::setForwardOnly(f); }
     173    bool isNull(int field) const { return QSqlQuery::isNull(field); }
     174    const QSqlDriver *driver(void) const { return QSqlQuery::driver(); }
     175    int at(void) const { return QSqlQuery::at(); }
     176
    145177    /// \brief Checks DB connection + login (login info via Mythcontext)
    146178    static bool testDBConnection();
    147179
    class MPUBLIC MSqlQuery : public QSqlQue 
    155187    static MSqlQueryInfo DDCon();
    156188
    157189  private:
     190    // Only QSql::In is supported as a param type and only named params...
     191    void bindValue(const QString&, const QVariant&, QSql::ParamType);
     192    void bindValue(int, const QVariant&, QSql::ParamType);
     193    void addBindValue(const QVariant&, QSql::ParamType = QSql::In);
     194
     195    bool seekDebug(const char *type, bool result,
     196                   int where, bool relative) const;
     197
    158198    MSqlDatabase *m_db;
    159199    bool m_isConnected;
    160200    bool m_returnConnection;
  • mythtv/libs/libmythdb/mythversion.h

    old new  
    1111/// Update this whenever the plug-in API changes.
    1212/// Including changes in the libmythdb, libmyth, libmythtv, libmythav* and
    1313/// libmythui class methods used by plug-ins.
    14 #define MYTH_BINARY_VERSION "0.24.20110505-1"
     14#define MYTH_BINARY_VERSION "0.24.20110804-1"
    1515
    1616/** \brief Increment this whenever the MythTV network protocol changes.
    1717 *
  • mythtv/libs/libmythtv/datadirect.cpp

    old new bool DataDirectProcessor::UpdateChannels 
    822822
    823823        if (!chan_update_q.exec())
    824824        {
    825             MythDB::DBError("Updating channel table",
    826                             chan_update_q.lastQuery());
     825            MythDB::DBError("Updating channel table", chan_update_q);
    827826        }
    828827    }
    829828
  • mythtv/libs/libmythtv/dbcheck.cpp

    old new NULL 
    36593659            {
    36603660                MythDB::DBError(QString("Unable to perform test for database "
    36613661                                "corruption before character set conversion."),
    3662                                 thequery);
     3662                                query);
    36633663                return false;
    36643664            }
    36653665            // If the conversion to utf8 resulted in warnings, the data in the
    NULL 
    36883688            {
    36893689                MythDB::DBError(QString("Error getting database warnings for "
    36903690                                "database corruption test."),
    3691                                 thequery);
     3691                                query);
    36923692                return false;
    36933693            }
    36943694            // Test creating an index to see if we had partial corruption that
    NULL 
    37023702                if (!ok)
    37033703                {
    37043704                    MythDB::DBError(QString("Index creation failed."),
    3705                                     thequery);
     3705                                    query);
    37063706                    VERBOSE(VB_IMPORTANT, "DB charset pre-conversion test "
    37073707                            "failed! Your database seems to be partially "
    37083708                            "corrupted. Please move the backup to a safe "
    NULL 
    37163716            thequery = QString("DROP TEMPORARY TABLE temp_%1;").arg(table);
    37173717            if (!query.exec(thequery))
    37183718                MythDB::DBError(QString("Error dropping temporary table %1.")
    3719                                 .arg(table), thequery);
     3719                                .arg(table), query);
    37203720
    37213721            tableIndex++;
    37223722        }
  • mythtv/programs/mythbackend/httpstatus.cpp

    old new void HttpStatus::FillStatusXML( QDomDocu 
    430430    MSqlQuery query(MSqlQuery::InitCon());
    431431    query.prepare("SELECT MAX(endtime) FROM program WHERE manualid = 0;");
    432432
    433     if (query.exec() && query.isActive() && query.size())
     433    if (query.exec() && query.next())
    434434    {
    435         query.next();
    436 
    437         if (query.isValid())
    438             GuideDataThrough = QDateTime::fromString(query.value(0).toString(),
    439                                                      Qt::ISODate);
     435        GuideDataThrough = QDateTime::fromString(
     436            query.value(0).toString(), Qt::ISODate);
    440437    }
    441438
    442439    guide.setAttribute("start", gCoreContext->GetSetting("mythfilldatabaseLastRunStart"));
  • mythtv/programs/mythbackend/main_helpers.cpp

    old new bool setupTVs(bool ismaster, bool &error 
    7575                        "DATE_FORMAT(starttime, '%Y%m%d%H%i00'), '_', "
    7676                        "DATE_FORMAT(endtime, '%Y%m%d%H%i00'), '.nuv') "
    7777                        "WHERE basename = '';"))
    78             MythDB::DBError("Updating record basename",
    79                                  query.lastQuery());
     78            MythDB::DBError("Updating record basename", query);
    8079
    8180        // Hack to make sure record.station gets set if the user
    8281        // downgrades to a prior version and creates new entries
    8382        // without it.
    8483        if (!query.exec("UPDATE channel SET callsign=chanid "
    8584                        "WHERE callsign IS NULL OR callsign='';"))
    86             MythDB::DBError("Updating channel callsign", query.lastQuery());
     85            MythDB::DBError("Updating channel callsign", query);
    8786
    8887        if (query.exec("SELECT MIN(chanid) FROM channel;"))
    8988        {
    bool setupTVs(bool ismaster, bool &error 
    9190            int min_chanid = query.value(0).toInt();
    9291            if (!query.exec(QString("UPDATE record SET chanid = %1 "
    9392                                    "WHERE chanid IS NULL;").arg(min_chanid)))
    94                 MythDB::DBError("Updating record chanid", query.lastQuery());
     93                MythDB::DBError("Updating record chanid", query);
    9594        }
    9695        else
    97             MythDB::DBError("Querying minimum chanid", query.lastQuery());
     96            MythDB::DBError("Querying minimum chanid", query);
    9897
    9998        MSqlQuery records_without_station(MSqlQuery::InitCon());
    10099        records_without_station.prepare("SELECT record.chanid,"
    bool setupTVs(bool ismaster, bool &error 
    113112                        records_without_station.value(0));
    114113                if (!update_record.exec())
    115114                {
    116                     MythDB::DBError("Updating record station",
    117                             update_record.lastQuery());
     115                    MythDB::DBError("Updating record station", update_record);
    118116                }
    119117            } while (records_without_station.next());
    120118        }
  • mythtv/programs/mythbackend/mainserver.cpp

    old new void MainServer::getGuideDataThrough(QDa 
    29292929    MSqlQuery query(MSqlQuery::InitCon());
    29302930    query.prepare("SELECT MAX(endtime) FROM program WHERE manualid = 0;");
    29312931
    2932     if (query.exec() && query.isActive() && query.size())
     2932    if (query.exec() && query.next())
    29332933    {
    2934         query.next();
    2935         if (query.isValid())
    2936             GuideDataThrough = QDateTime::fromString(query.value(0).toString(),
    2937                                                      Qt::ISODate);
     2934        GuideDataThrough = QDateTime::fromString(
     2935            query.value(0).toString(), Qt::ISODate);
    29382936    }
    29392937}
    29402938
  • mythtv/programs/mythbackend/scheduler.cpp

    old new void Scheduler::AddNewRecords(void) 
    36043604    {
    36053605        result.prepare("DROP TABLE IF EXISTS sched_temp_record;");
    36063606        if (!result.exec())
    3607             MythDB::DBError("AddNewRecords sched_temp_record", query);
     3607            MythDB::DBError("AddNewRecords sched_temp_record", result);
    36083608    }
    36093609
    36103610    result.prepare("DROP TABLE IF EXISTS sched_temp_recorded;");
    36113611    if (!result.exec())
    3612         MythDB::DBError("AddNewRecords drop table", query);
     3612        MythDB::DBError("AddNewRecords drop table", result);
    36133613}
    36143614
    36153615void Scheduler::AddNotListed(void) {
  • mythtv/programs/mythfrontend/progfind.cpp

    old new void ProgFinder::getShowNames() 
    527527    query.bindValues(bindings);
    528528    if (!query.exec())
    529529    {
    530         MythDB::DBError("getShowNames", thequery);
     530        MythDB::DBError("getShowNames", query);
    531531        return;
    532532    }
    533533
  • mythplugins/mythmusic/mythmusic/smartplaylist.cpp

    old new void SmartPLResultViewer::setSQL(QString 
    17331733                query.value(4).toString(),
    17341734                query.value(5).toString(),
    17351735                query.value(6).toString());
    1736         } while (query.prev());
     1736        } while (query.previous());
    17371737    }
    17381738
    17391739    // set selection to first item
  • mythplugins/mythweather/mythweather/weatherSource.cpp

    old new ScriptInfo *WeatherSource::ProbeScript(c 
    304304            db.bindValue(":EMAIL", info.email);
    305305            if (!db.exec())
    306306            {
    307                 MythDB::DBError("Updating weather source settings.", query);
     307                MythDB::DBError("Updating weather source settings.", db);
    308308                return NULL;
    309309            }
    310310        }
    ScriptInfo *WeatherSource::ProbeScript(c 
    338338        db.bindValue(":TYPES", info.types.join(","));
    339339        if (!db.exec())
    340340        {
    341             MythDB::DBError("Inserting weather source", query);
     341            MythDB::DBError("Inserting weather source", db);
    342342            return NULL;
    343343        }
    344344        query = "SELECT sourceid FROM weathersourcesettings "
    ScriptInfo *WeatherSource::ProbeScript(c 
    350350        db.bindValue(":NAME", info.name);
    351351        if (!db.exec())
    352352        {
    353             MythDB::DBError("Getting weather sourceid", query);
     353            MythDB::DBError("Getting weather sourceid", db);
    354354            return NULL;
    355355        }
    356356        else if (!db.next())