Added lookahead caching for addressbook (SQL-only) for speed improvement.

3 files changed, 151 insertions, 36 deletions

diff --git a/libopie2/opiepim/backend/ocontactaccessbackend_sql.cpp b/libopie2/opiepim/backend/ocontactaccessbackend_sql.cpp
index dda23cc..abfd944 100644
--- a/libopie2/opiepim/backend/ocontactaccessbackend_sql.cpp
+++ b/libopie2/opiepim/backend/ocontactaccessbackend_sql.cpp
@@ -291,46 +291,47 @@ namespace {
 
 
 
     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();
+	    if ( m_uids.count() == 0 )
+		    return single();
+	    else
+		    return multi();
     }
-    /*
-      else
-            return multi();
-            }
-        QString FindQuery::multi()const {
-        QString qu = "select uid, type, value from addressbook where";
-        for (uint i = 0; i < m_uids.count(); i++ ) {
-            qu += " UID = " + QString::number( m_uids[i] ) + " OR";
-        }
-        qu.remove( qu.length()-2, 2 ); // Hmmmm..
-        return qu;
+        
+    QString FindQuery::multi()const {
+	    QString qu = "select * from addressbook where";
+	    for (uint i = 0; i < m_uids.count(); i++ ) {
+		    qu += " uid = " + QString::number( m_uids[i] ) + " OR";
+	    }
+	    qu.remove( qu.length()-2, 2 ); // Hmmmm..
+
+	    odebug << "find query: " << qu << "" << oendl;
+	    return qu;
     }
-    */
-    QString FindQuery::single()const{
-        QString qu = "select *";
-        qu += " from addressbook where uid = " + QString::number(m_uid);
 
-        // owarn << "find query: " << qu << "" << oendl;
-        return qu;
+    QString FindQuery::single()const{
+	    QString qu = "select *";
+	    qu += " from addressbook where uid = " + QString::number(m_uid);
+	    
+	    // owarn << "find query: " << qu << "" << oendl;
+	    return qu;
     }
 
 
     FindCustomQuery::FindCustomQuery(int uid)
         : OSQLQuery(), m_uid( uid ) {
     }
     FindCustomQuery::FindCustomQuery(const QArray<int>& ints)
         : OSQLQuery(), m_uids( ints ){
     }
     FindCustomQuery::~FindCustomQuery() {
     }
     QString FindCustomQuery::query()const{
@@ -464,35 +465,76 @@ bool OPimContactAccessBackend_SQL::remove ( int uid )
 
 bool OPimContactAccessBackend_SQL::replace ( const OPimContact &contact )
 {
     if ( !remove( contact.uid() ) )
         return false;
 
     return add( contact );
 }
 
 
 OPimContact OPimContactAccessBackend_SQL::find ( int uid ) const
 {
-    odebug << "OPimContactAccessBackend_SQL::find()" << oendl;
+    odebug << "OPimContactAccessBackend_SQL::find(" << uid << ")" << oendl;
     QTime t;
     t.start();
 
     OPimContact retContact( requestNonCustom( uid ) );
     retContact.setExtraMap( requestCustom( uid ) );
 
     odebug << "OPimContactAccessBackend_SQL::find() needed: " << t.elapsed() << " ms" << oendl;
     return retContact;
 }
 
+OPimContact OPimContactAccessBackend_SQL::find( int uid, const QArray<int>& queryUids, uint current, Frontend::CacheDirection direction ) const
+{
+    odebug << "OPimContactAccessBackend_SQL::find( ..multi.. )" << oendl;
+    odebug << "searching for " << uid << "" << oendl;
+
+    QTime t;
+    t.start();
+	
+    uint numReadAhead = readAhead();
+    QArray<int> searchList( numReadAhead );
+ 
+    uint size =0;
+
+    // Build an array with all elements which should be requested and cached
+    // We will just request "numReadAhead" elements, starting from "current" position in
+    // the list of many uids !
+    switch( direction ) {
+        /* forward */
+    case Frontend::Forward:
+        for ( uint i = current; i < queryUids.count() && size < numReadAhead; i++ ) {
+            searchList[size] = queryUids[i];
+            size++;
+        }
+        break;
+        /* reverse */
+    case Frontend::Reverse:
+        for ( uint i = current; i != 0 && size <  numReadAhead; i-- ) {
+            searchList[size] = queryUids[i];
+            size++;
+        }
+        break;
+    }
+
+    //Shrink to real size..
+    searchList.resize( size );
+
+    OPimContact retContact( requestContactsAndCache( uid, searchList ) );
+
+    odebug << "OPimContactAccessBackend_SQL::find( ..multi.. ) needed: " << t.elapsed() << " ms" << oendl;
+    return retContact;
+}
 
 
 QArray<int> OPimContactAccessBackend_SQL::queryByExample ( const OPimContact &query, int settings, const QDateTime& qd )
 {
     QString qu = "SELECT uid FROM addressbook WHERE";
     QString searchQuery ="";
 
     QDate startDate;
 
     if ( qd.isValid() )
         startDate = qd.date();
     else
@@ -759,47 +801,104 @@ QArray<int> OPimContactAccessBackend_SQL::extractUids( OSQLResult& res ) const
     }
     odebug << "extractUids ready: count2 = " << i << " needs " << t.elapsed() << " ms" << oendl;
 
     return ints;
 
 }
 
 QMap<int, QString>  OPimContactAccessBackend_SQL::requestNonCustom( int uid ) const
 {
     QTime t;
     t.start();
 
-    QMap<int, QString> nonCustomMap;
-
     int t2needed = 0;
     int t3needed = 0;
     QTime t2;
     t2.start();
     FindQuery query( uid );
     OSQLResult res_noncustom = m_driver->query( &query );
     t2needed = t2.elapsed();
 
     OSQLResultItem resItem = res_noncustom.first();
 
+    QMap<int, QString> nonCustomMap;
     QTime t3;
     t3.start();
+    nonCustomMap = fillNonCustomMap( resItem );
+    t3needed = t3.elapsed();
+    
+
+    // odebug << "Adding UID: " << resItem.data( "uid" ) << "" << oendl;
+    odebug << "RequestNonCustom needed: insg.:" << t.elapsed() << " ms, query: " << t2needed
+           << " ms, mapping: " << t3needed << " ms" << oendl;
+
+    return nonCustomMap;
+}
+
+/* Returns contact requested by uid and fills cache with contacts requested by uids in the cachelist */ 
+OPimContact OPimContactAccessBackend_SQL::requestContactsAndCache( int uid, const QArray<int>& uidlist )const
+{
+	// We want to get all contacts with one query.
+	// We don't have to add the given uid to the uidlist, it is expected to be there already (see opimrecordlist.h).
+	// All contacts will be stored in the cache, afterwards the contact with the user id "uid" will be returned
+	// by using the cache..  
+	QArray<int> cachelist = uidlist;
+
+	odebug << "Reqest and cache" << cachelist.size() << "elements !" << oendl;
+
+	QTime t;
+	t.start();
+
+	int t2needed = 0;
+	int t3needed = 0;
+	QTime t2;
+	t2.start();
+	FindQuery query( cachelist );
+	OSQLResult res_noncustom = m_driver->query( &query );
+	t2needed = t2.elapsed();
+
+	QMap<int, QString> nonCustomMap;
+	QTime t3;
+	t3.start();
+	OSQLResultItem resItem = res_noncustom.first();
+	do {
+		OPimContact contact( fillNonCustomMap( resItem ) );
+		contact.setExtraMap( requestCustom( contact.uid() ) );
+		odebug << "Caching uid: " << contact.uid() << oendl;
+		cache( contact );
+		resItem = res_noncustom.next();
+	} while ( ! res_noncustom.atEnd() ); //atEnd() is true if we are past(!) the list !!
+	t3needed = t3.elapsed();
+    
+
+	// odebug << "Adding UID: " << resItem.data( "uid" ) << "" << oendl;
+	odebug << "RequestContactsAndCache needed: insg.:" << t.elapsed() << " ms, query: " << t2needed
+	       << " ms, mapping: " << t3needed << " ms" << oendl;
+	
+	return cacheFind( uid );
+}
+
+QMap<int, QString> OPimContactAccessBackend_SQL::fillNonCustomMap( const OSQLResultItem& resultItem ) const
+{
+    QMap<int, QString> nonCustomMap;
+
     // Now loop through all columns
     QStringList fieldList = OPimContactFields::untrfields( false );
     QMap<QString, int> translate = OPimContactFields::untrFieldsToId();
     for ( QStringList::Iterator it = ++fieldList.begin(); it != fieldList.end(); ++it ){
         // Get data for the selected column and store it with the
         // corresponding id into the map..
 
         int id =  translate[*it];
-        QString value = resItem.data( (*it) );
+        QString value = resultItem.data( (*it) );
 
         // odebug << "Reading " << (*it) << "... found: " << value << "" << oendl;
 
         switch( id ){
         case Qtopia::Birthday:
         case Qtopia::Anniversary:{
             // Birthday and Anniversary are encoded special ( yyyy-mm-dd )
             QStringList list = QStringList::split( '-', value );
             QStringList::Iterator lit = list.begin();
             int year  = (*lit).toInt();
             int month = (*(++lit)).toInt();
             int day   = (*(++lit)).toInt();
@@ -807,35 +906,30 @@ QMap<int, QString>  OPimContactAccessBackend_SQL::requestNonCustom( int uid ) co
                  QDate date( year, month, day );
                  nonCustomMap.insert( id, OPimDateConversion::dateToString( date ) );
             }
         }
             break;
         case Qtopia::AddressCategory:
             odebug << "Category is: " << value << "" << oendl;
         default:
             nonCustomMap.insert( id, value );
         }
     }
 
-    // First insert uid
-    nonCustomMap.insert( Qtopia::AddressUid, resItem.data( "uid" ) );
-    t3needed = t3.elapsed();
-
-    // odebug << "Adding UID: " << resItem.data( "uid" ) << "" << oendl;
-    odebug << "RequestNonCustom needed: insg.:" << t.elapsed() << " ms, query: " << t2needed
-           << " ms, mapping: " << t3needed << " ms" << oendl;
+    nonCustomMap.insert( Qtopia::AddressUid, resultItem.data( "uid" ) );
 
     return nonCustomMap;
 }
 
+
 QMap<QString, QString>  OPimContactAccessBackend_SQL::requestCustom( int uid ) const
 {
     QTime t;
     t.start();
 
     QMap<QString, QString> customMap;
 
     FindCustomQuery query( uid );
     OSQLResult res_custom = m_driver->query( &query );
 
     if ( res_custom.state() == OSQLResult::Failure ) {
         owarn << "OSQLResult::Failure in find query !!" << oendl;
diff --git a/libopie2/opiepim/backend/ocontactaccessbackend_sql.h b/libopie2/opiepim/backend/ocontactaccessbackend_sql.h
index ba122ec..4f81735 100644
--- a/libopie2/opiepim/backend/ocontactaccessbackend_sql.h
+++ b/libopie2/opiepim/backend/ocontactaccessbackend_sql.h
@@ -64,49 +64,50 @@ class OPimContactAccessBackend_SQL : public OPimContactAccessBackend {
 
 	bool save();
 
 	bool load ();
 
 	void clear ();
 
 	bool wasChangedExternally();
 
 	QArray<int> allRecords() const;
 
 	OPimContact find ( int uid ) const;
-	// FIXME: Add lookahead-cache support !
-	//OPimContact find(int uid, const QArray<int>&, uint cur, Frontend::CacheDirection )const;
+	OPimContact find( int uid, const QArray<int>&, uint cur, Frontend::CacheDirection ) const; 
 
 	QArray<int> queryByExample ( const OPimContact &query, int settings, 
 				     const QDateTime& d );
 
 	QArray<int> matchRegexp(  const QRegExp &r ) const;
 
 	const uint querySettings();
 
 	bool hasQuerySettings (uint querySettings) const;
 
 	// Currently only asc implemented..
 	QArray<int> sorted( bool asc,  int , int ,  int );
 	bool add ( const OPimContact &newcontact );
 
 	bool replace ( const OPimContact &contact );
 
 	bool remove ( int uid );
 	bool reload();
 
  private:
 	QArray<int> extractUids( Opie::DB::OSQLResult& res ) const;
 	QMap<int, QString>  requestNonCustom( int uid ) const;
 	QMap<QString, QString>  requestCustom( int uid ) const;
+	QMap<int, QString> fillNonCustomMap( const Opie::DB::OSQLResultItem& resultItem ) const;
+	OPimContact requestContactsAndCache( int uid, const QArray<int>& cachelist ) const;
 	void update();
 
  protected:
 	bool m_changed;
 	QString m_fileName;
 	QArray<int> m_uids;
 
 	Opie::DB::OSQLDriver* m_driver;
 };
 
 }
 
diff --git a/libopie2/opiepim/backend/opimaccessbackend.h b/libopie2/opiepim/backend/opimaccessbackend.h
index 0682063..15a7b7f 100644
--- a/libopie2/opiepim/backend/opimaccessbackend.h
+++ b/libopie2/opiepim/backend/opimaccessbackend.h
@@ -87,25 +87,25 @@ public:
      * queryByExample for T with the given Settings
      * 
      */
     virtual QArray<int> queryByExample( const T& t, int settings, const QDateTime& d = QDateTime() ) = 0;
 
     /**
      * find the OPimRecord with uid @param uid
      * returns T and T.isEmpty() if nothing was found
      */
     virtual T find(int uid )const  = 0;
 
     virtual T find(int uid, const QArray<int>& items,
-                   uint current, typename Frontend::CacheDirection )const ;
+                   uint current, typename Frontend::CacheDirection ) const;
     /**
      * clear the back end
      */
     virtual void clear() = 0;
 
     /**
      * add T
      */
     virtual bool add( const T& t ) = 0;
 
     /**
      * remove
@@ -119,26 +119,34 @@ public:
 
     /*
      * setTheFrontEnd!!!
      */
     void setFrontend( Frontend* front );
 
     /**
      * set the read ahead count
      */
     void setReadAhead( uint count );
 protected:
     int access()const;
+
     void cache( const T& t )const;
 
+    /** 
+     * Returns the element with given uid out of the cache.
+     * Returns empty element if nothing was found.
+     * <b>Attention:</b> This just works if we have a frontend which contains the cache !
+     */
+    T cacheFind( int uid ) const;
+
     /**
      * use a prime number here!
      */
     void setSaneCacheSize( int );
 
     uint readAhead()const;
 
 private:
     OPimAccessBackendPrivate *d;
     Frontend* m_front;
     uint m_read;
     int m_acc;
@@ -152,35 +160,47 @@ OPimAccessBackend<T>::OPimAccessBackend(int acc)
     m_front = 0l;
 }
 template <class T>
 OPimAccessBackend<T>::~OPimAccessBackend() {
 
 }
 template <class T>
 void OPimAccessBackend<T>::setFrontend( Frontend* fr ) {
     m_front = fr;
 }
 template <class T>
 void OPimAccessBackend<T>::cache( const T& t )const {
-    if (m_front )
+    if ( m_front )
         m_front->cache( t );
 }
+
+template <class T>
+T OPimAccessBackend<T>::cacheFind( int uid )const {
+	if ( ! m_front ){
+		qWarning ( "No frontend assigned ! Therefore we cannot access the cache to return the right element!" );
+		return T();
+	}
+
+	return m_front->cacheFind( uid );
+}
+
 template <class T>
 void OPimAccessBackend<T>::setSaneCacheSize( int size) {
-    if (m_front )
+    if ( m_front )
         m_front->setSaneCacheSize( size );
 }
 template <class T>
 T OPimAccessBackend<T>::find( int uid, const QArray<int>&,
-                              uint, typename Frontend::CacheDirection )const {
+                              uint, typename Frontend::CacheDirection ) const{
+    qDebug( "*** Lookahead feature not supported. Fallback to default find!" );
     return find( uid );
 }
 template <class T>
 void OPimAccessBackend<T>::setReadAhead( uint count ) {
     m_read = count;
 }
 template <class T>
 uint OPimAccessBackend<T>::readAhead()const {
     return m_read;
 }
 template <class T>
 int OPimAccessBackend<T>::access()const {