Implement read ahead on the XML resource...

Scrolling is now noticeable faster with 10.000 items
but not as fast the XML backend...
OPimCache can be tuned and Query->OTodo too

3 files changed, 81 insertions, 7 deletions

diff --git a/libopie2/opiepim/backend/otodoaccesssql.cpp b/libopie2/opiepim/backend/otodoaccesssql.cpp
index 8add9f7..a059dab 100644
--- a/libopie2/opiepim/backend/otodoaccesssql.cpp
+++ b/libopie2/opiepim/backend/otodoaccesssql.cpp
@@ -60,51 +60,55 @@ namespace {
         RemoveQuery(int uid );
         ~RemoveQuery();
         QString query()const;
     private:
         int m_uid;
     };
 
     /**
      * Clears (delete) a Table
      */
     class ClearQuery : public OSQLQuery {
     public:
         ClearQuery();
         ~ClearQuery();
         QString query()const;
 
     };
 
     /**
      * a find query
      */
     class FindQuery : public OSQLQuery {
     public:
         FindQuery(int uid);
+        FindQuery(const QArray<int>& );
         ~FindQuery();
         QString query()const;
     private:
+        QString single()const;
+        QString multi()const;
+        QArray<int> m_uids;
         int m_uid;
     };
 
     /**
      * overdue query
      */
     class OverDueQuery : public OSQLQuery {
     public:
         OverDueQuery();
         ~OverDueQuery();
         QString query()const;
     };
     class EffQuery : public OSQLQuery {
     public:
         EffQuery( const QDate&, const QDate&, bool inc );
         ~EffQuery();
         QString query()const;
     private:
         QString with()const;
         QString out()const;
         QDate m_start;
         QDate m_end;
         bool m_inc :1;
     };
@@ -117,92 +121,111 @@ namespace {
         qu += "create table todolist( uid, categories, completed, progress, ";
         qu += "summary, DueDate, priority, description )";
         return qu;
     }
 
     LoadQuery::LoadQuery() : OSQLQuery() {}
     LoadQuery::~LoadQuery() {}
     QString LoadQuery::query()const {
         QString qu;
         qu += "select distinct uid from todolist";
 
         return qu;
     }
 
     InsertQuery::InsertQuery( const OTodo& todo )
         : OSQLQuery(), m_todo( todo ) {
     }
     InsertQuery::~InsertQuery() {
     }
     /*
      * converts from a OTodo to a query
      * we leave out X-Ref + Alarms
      */
     QString InsertQuery::query()const{
+
         int year, month, day;
         year = month = day = 0;
         if (m_todo.hasDueDate() ) {
             QDate date = m_todo.dueDate();
             year = date.year();
             month = date.month();
             day = date.day();
         }
         QString qu;
         qu  = "insert into todolist VALUES(" +  QString::number( m_todo.uid() ) + ",'" + m_todo.idsToString( m_todo.categories() ) + "',";
         qu += QString::number( m_todo.isCompleted() ) + "," + QString::number( m_todo.progress() ) + ",";
         qu += "'"+m_todo.summary()+"','"+QString::number(year)+"-"+QString::number(month)+"-"+QString::number(day)+"',";
         qu += QString::number(m_todo.priority() ) +",'" + m_todo.description() + "')";
 
         qWarning("add %s", qu.latin1() );
         return qu;
     }
 
     RemoveQuery::RemoveQuery(int uid )
         : OSQLQuery(), m_uid( uid ) {}
     RemoveQuery::~RemoveQuery() {}
     QString RemoveQuery::query()const {
         QString qu = "DELETE from todolist where uid = " + QString::number(m_uid);
         return qu;
     }
 
 
     ClearQuery::ClearQuery()
         : OSQLQuery() {}
     ClearQuery::~ClearQuery() {}
     QString ClearQuery::query()const {
         QString qu = "drop table todolist";
         return qu;
     }
     FindQuery::FindQuery(int uid)
         : OSQLQuery(), m_uid(uid ) {
     }
+    FindQuery::FindQuery(const QArray<int>& ints)
+        : OSQLQuery(), m_uids(ints){
+    }
     FindQuery::~FindQuery() {
     }
     QString FindQuery::query()const{
+        if (m_uids.count() == 0 )
+            return single();
+        else
+            return multi();
+    }
+    QString FindQuery::single()const{
         QString qu = "select uid, categories, completed, progress, summary, ";
         qu += "DueDate, priority, description from todolist where uid = " + QString::number(m_uid);
         return qu;
     }
+    QString FindQuery::multi()const {
+        QString qu = "select uid, categories, completed, progress, summary, ";
+        qu += "DueDate, priority, description from todolist where ";
+        for (uint i = 0; i < m_uids.count(); i++ ) {
+            qu += " UID = " + QString::number( m_uids[i] ) + " OR";
+        }
+        qu.remove( qu.length()-2, 2 );
+        return qu;
+    }
 
     OverDueQuery::OverDueQuery(): OSQLQuery() {}
     OverDueQuery::~OverDueQuery() {}
     QString OverDueQuery::query()const {
         QDate date = QDate::currentDate();
         QString str;
         str = QString("select uid from todolist where DueDate ='%1-%2-%3'").arg(date.year() ).arg(date.month() ).arg(date.day() );
 
         return str;
     }
 
 
     EffQuery::EffQuery( const QDate& start, const QDate& end, bool inc )
         : OSQLQuery(), m_start( start ), m_end( end ),m_inc(inc) {}
     EffQuery::~EffQuery() {}
     QString EffQuery::query()const {
         return m_inc ? with() : out();
     }
     QString EffQuery::with()const {
         QString str;
         str = QString("select uid from todolist where ( DueDate >= '%1-%2-%3' AND DueDate <= '%4-%5-%6' ) OR DueDate = '0-0-0' ")
             .arg( m_start.year() ).arg( m_start.month() ).arg( m_start.day() )
             .arg( m_end  .year() ).arg( m_end  .month() ).arg( m_end  .day() );
         return str;
@@ -240,48 +263,81 @@ bool OTodoAccessBackendSQL::load(){
 
     update();
     qWarning("loaded %d", m_uids.count() );
     return true;
 }
 bool OTodoAccessBackendSQL::reload(){
     return load();
 }
 
 bool OTodoAccessBackendSQL::save(){
     return m_driver->close();
 }
 QArray<int> OTodoAccessBackendSQL::allRecords()const {
     return m_uids;
 }
 QArray<int> OTodoAccessBackendSQL::queryByExample( const OTodo& , int  ){
     QArray<int> ints(0);
     return ints;
 }
 OTodo OTodoAccessBackendSQL::find(int uid ) const{
     FindQuery query( uid );
     return todo( m_driver->query(&query) );
 
 }
+OTodo OTodoAccessBackendSQL::find( int uid, const QArray<int>& ints,
+                                   uint cur, Frontend::CacheDirection dir ) const{
+    qWarning("searching for %d", uid );
+    QArray<int> search( 8 );
+    uint size =0;
+    OTodo to;
+
+    // we try to cache 8 items
+    switch( dir ) {
+        /* forward */
+    case 0:
+        for (uint i = cur; i < ints.count() && size < 8; i++ ) {
+            qWarning("size %d %d", size,  ints[i] );
+            search[size] = ints[i];
+            size++;
+        }
+        break;
+        /* reverse */
+    case 1:
+        for (uint i = cur; i >= 0 && size <  8; i-- ) {
+            search[size] = ints[i];
+            size++;
+        }
+        break;
+    }
+    search.resize( size );
+    FindQuery query( search );
+    OSQLResult res = m_driver->query( &query  );
+    if ( res.state() != OSQLResult::Success )
+        return to;
+
+    return todo( res );
+}
 void OTodoAccessBackendSQL::clear() {
     ClearQuery cle;
     OSQLResult res = m_driver->query( &cle );
     CreateQuery qu;
     res = m_driver->query(&qu);
 }
 bool OTodoAccessBackendSQL::add( const OTodo& t) {
     InsertQuery ins( t );
     OSQLResult res = m_driver->query( &ins );
 
     if ( res.state() == OSQLResult::Failure )
         return false;
     int c = m_uids.count();
     m_uids.resize( c+1 );
     m_uids[c] = t.uid();
 
     return true;
 }
 bool OTodoAccessBackendSQL::remove( int uid ) {
     RemoveQuery rem( uid );
     OSQLResult res = m_driver->query(&rem );
 
     if ( res.state() == OSQLResult::Failure )
         return false;
@@ -372,56 +428,69 @@ QArray<int> OTodoAccessBackendSQL::sorted( bool asc, int sortOrder,
     OSQLRawQuery raw(query );
     return uids( m_driver->query(&raw) );
 }
 bool OTodoAccessBackendSQL::date( QDate& da, const QString& str ) const{
     if ( str == "0-0-0" )
         return false;
     else{
         int day, year, month;
         QStringList list = QStringList::split("-", str );
         year = list[0].toInt();
         month = list[1].toInt();
         day = list[2].toInt();
         da.setYMD( year, month, day );
         return true;
     }
 }
 OTodo OTodoAccessBackendSQL::todo( const OSQLResult& res) const{
     if ( res.state() == OSQLResult::Failure ) {
         OTodo to;
         return to;
     }
 
     OSQLResultItem::ValueList list = res.results();
     OSQLResultItem::ValueList::Iterator it = list.begin();
-
+    qWarning("todo1");
+    OTodo to = todo( (*it) );
+    cache( to );
+    ++it;
+
+    for ( ; it != list.end(); ++it ) {
+        qWarning("caching");
+        cache( todo( (*it) ) );
+    }
+    return to;
+}
+OTodo OTodoAccessBackendSQL::todo( OSQLResultItem& item )const {
+    qWarning("todo");
     bool has = false; QDate da = QDate::currentDate();
-    has = date( da, (*it).data("DueDate") );
-    QStringList cats = QStringList::split(";", (*it).data("categories") );
+    has = date( da, item.data("DueDate") );
+    QStringList cats = QStringList::split(";", item.data("categories") );
 
-    OTodo to( (bool)(*it).data("completed").toInt(), (*it).data("priority").toInt(),
-              cats, (*it).data("summary"), (*it).data("description"),
-              (*it).data("progress").toUShort(), has, da, (*it).data("uid").toInt() );
+    OTodo to( (bool)item.data("completed").toInt(), item.data("priority").toInt(),
+              cats, item.data("summary"), item.data("description"),
+              item.data("progress").toUShort(), has, da,
+              item.data("uid").toInt() );
     return to;
 }
 OTodo OTodoAccessBackendSQL::todo( int uid )const {
     FindQuery find( uid );
     return todo( m_driver->query(&find) );
 }
 /*
  * update the dict
  */
 void OTodoAccessBackendSQL::fillDict() {
     /* initialize dict */
     /*
      * UPDATE dict if you change anything!!!
      */
     m_dict.setAutoDelete( TRUE );
     m_dict.insert("Categories" ,     new int(OTodo::Category)         );
     m_dict.insert("Uid" ,            new int(OTodo::Uid)              );
     m_dict.insert("HasDate" ,        new int(OTodo::HasDate)          );
     m_dict.insert("Completed" ,      new int(OTodo::Completed)        );
     m_dict.insert("Description" ,    new int(OTodo::Description)      );
     m_dict.insert("Summary" ,        new int(OTodo::Summary)          );
     m_dict.insert("Priority" ,       new int(OTodo::Priority)         );
     m_dict.insert("DateDay" ,        new int(OTodo::DateDay)          );
     m_dict.insert("DateMonth" ,      new int(OTodo::DateMonth)        );
diff --git a/libopie2/opiepim/backend/otodoaccesssql.h b/libopie2/opiepim/backend/otodoaccesssql.h
index 6c5f50a..c1aa2ed 100644
--- a/libopie2/opiepim/backend/otodoaccesssql.h
+++ b/libopie2/opiepim/backend/otodoaccesssql.h
@@ -1,46 +1,49 @@
 #ifndef OPIE_PIM_ACCESS_SQL_H
 #define OPIE_PIM_ACCESS_SQL_H
 
 #include <qasciidict.h>
 
 #include "otodoaccessbackend.h"
 
 class OSQLDriver;
 class OSQLResult;
+class OSQLResultItem;
 class OTodoAccessBackendSQL : public OTodoAccessBackend {
 public:
     OTodoAccessBackendSQL( const QString& file );
     ~OTodoAccessBackendSQL();
 
     bool load();
     bool reload();
     bool save();
     QArray<int> allRecords()const;
 
     QArray<int> queryByExample( const OTodo& t, int sort );
     OTodo find(int uid)const;
+    OTodo find(int uid, const QArray<int>&, uint cur, Frontend::CacheDirection )const;
     void clear();
     bool add( const OTodo& t );
     bool remove( int uid );
     bool replace( const OTodo& t );
 
     QArray<int> overDue();
     QArray<int> effectiveToDos( const QDate& start,
                                 const QDate& end, bool includeNoDates );
     QArray<int> sorted(bool asc, int sortOrder, int sortFilter, int cat );
 
 private:
     void update();
     void fillDict();
     inline bool date( QDate& date, const QString& )const;
     inline OTodo todo( const OSQLResult& )const;
+    inline OTodo todo( OSQLResultItem& )const;
     inline QArray<int> uids( const OSQLResult& )const;
     OTodo todo( int uid )const;
 
     QAsciiDict<int> m_dict;
     OSQLDriver* m_driver;
     QArray<int> m_uids;
 };
 
 
 #endif
diff --git a/libopie2/opiepim/core/opimcache.h b/libopie2/opiepim/core/opimcache.h
index 067f6e7..839550c 100644
--- a/libopie2/opiepim/core/opimcache.h
+++ b/libopie2/opiepim/core/opimcache.h
@@ -40,49 +40,51 @@ public:
 
 private:
     QIntCache<Item> m_cache;
 };
 
 // Implementation
 template <class T>
 OPimCacheItem<T>::OPimCacheItem( const T& t )
     : m_t(t) {
 }
 template <class T>
 OPimCacheItem<T>::~OPimCacheItem() {
 
 }
 template <class T>
 T OPimCacheItem<T>::record()const {
     return m_t;
 }
 template <class T>
 void OPimCacheItem<T>::setRecord( const T& t ) {
     m_t = t;
 }
 // Cache
 template <class T>
-OPimCache<T>::OPimCache() {
+OPimCache<T>::OPimCache()
+    : m_cache(100, 53 )
+{
     m_cache.setAutoDelete( TRUE );
 }
 template <class T>
 OPimCache<T>::~OPimCache() {
 
 }
 template <class T>
 bool OPimCache<T>::contains(int uid )const {
     Item* it = m_cache.find( uid, FALSE );
     if (!it)
         return false;
     return true;
 }
 template <class T>
 void OPimCache<T>::invalidate() {
     m_cache.clear();
 }
 template <class T>
 void OPimCache<T>::setSize( int size ) {
     m_cache.setMaxCost( size );
 }
 template <class T>
 T OPimCache<T>::find(int uid )const {
     Item *it = m_cache.find( uid );