*Basic* regex caching for massive search speedup (and I mean lots)

Yes, it's ugly. Yes, it's simple. Yes it probably breaks several fundamental coding rules.
Yes, I'm open to suggestions as to how to do it better and more in the Opie way.

1 files changed, 21 insertions, 14 deletions

diff --git a/libopie2/opiedb/osqlitedriver.cpp b/libopie2/opiedb/osqlitedriver.cpp
index eea1093..4eda9b9 100644
--- a/libopie2/opiedb/osqlitedriver.cpp
+++ b/libopie2/opiedb/osqlitedriver.cpp
@@ -20,150 +20,157 @@
 ++=   -.     .`     .:       details.
  :     =  ...= . :.=-
  -.   .:....=;==+<;          You should have received a copy of the GNU
   -_. . .   )=.  =           Library General Public License along with
     --        :-=`           this library; see the file COPYING.LIB.
                              If not, write to the Free Software Foundation,
                              Inc., 59 Temple Place - Suite 330,
                              Boston, MA 02111-1307, USA.
 
 */
 
 #include "osqlquery.h"
 #include "osqlitedriver.h"
 
 #include <opie2/odebug.h>
 
 #include <stdlib.h>
 #include <regex.h>
 #include <stdio.h>
 
 // fromLocal8Bit() does not work as expected. Thus it
 // is replaced by fromLatin1() (eilers)
 #define __BUGGY_LOCAL8BIT_
 
+        char *regex_raw;
+        regex_t regex_c;
 
 using namespace Opie::DB;
 using namespace Opie::DB::Internal;
 
 namespace {
     struct Query {
         OSQLError::ValueList errors;
         OSQLResultItem::ValueList items;
         OSQLiteDriver *driver;
     };
 }
 
 
 OSQLiteDriver::OSQLiteDriver( QLibrary *lib )
     : OSQLDriver( lib )
 {
     m_sqlite = 0l;
 }
 
 
 OSQLiteDriver::~OSQLiteDriver() {
     close();
 }
 
 
 QString OSQLiteDriver::id()const {
     return QString::fromLatin1("SQLite");
 }
 
 void OSQLiteDriver::setUserName( const QString& ) {}
 
 
 void OSQLiteDriver::setPassword( const QString& ) {}
 
 
 void OSQLiteDriver::setUrl( const QString& url ) {
     m_url = url;
 }
 
 
 void OSQLiteDriver::setOptions( const QStringList& ) {
 }
 
-/*------------------------------------------------------------------/*
+/*
  * Functions to patch a regex search into sqlite
- * -----------------------------------------------------------------*/
+ */
 int sqliteRlikeCompare(const char *zPattern, const char *zString){
-          regex_t regex;
         int res;
-        if ( zPattern==NULL || zString==NULL ) {
-                printf("One of the args was null!\n");
-                return 0;
-        }
-        res = regcomp(&regex, zPattern, REG_EXTENDED);
-        if ( res != 0 ) {
-                printf("Regcomp failed with code %u on string %s\n",res,zPattern);
-
+        if (regex_raw == NULL || (strcmp (zPattern, regex_raw) != 0)){
+                if (regex_raw != NULL) {
+                    free(regex_raw);
+                    regfree(&regex_c);
+                }
+                regex_raw = (char *)malloc(strlen(zPattern)+1);
+                strncpy(regex_raw, zPattern, strlen(zPattern)+1);
+                res = regcomp(&regex_c, zPattern, REG_EXTENDED);
+                if ( res != 0 ) {
+                    printf("Regcomp failed with code %u on string %s\n",res,zPattern);
+                    free(regex_raw);
+                    regex_raw=NULL;
                 return 0;
+                }
         }
-        res = (regexec(&regex, zString, 0, NULL, 0)==0);
-        regfree(&regex);
+        res = (regexec(&regex_c, zString, 0, NULL, 0)==0);
         return res;
 }
 
 void rlikeFunc(sqlite_func *context, int arg, const char **argv){
         if( argv[0]==0 || argv[1]==0 ) return;
                 sqlite_set_result_int(context,
                 sqliteRlikeCompare((const char*)argv[0],
         (const char*)argv[1]));
 }
 
 /*
  * try to open a db specified via setUrl
  * and options
  */
 bool OSQLiteDriver::open() {
     char *error;
     qDebug("OSQLiteDriver::open: about to open");
     m_sqlite = sqlite_open(m_url.local8Bit(),
                            0,
                            &error );
 
     /* failed to open */
     if (m_sqlite == 0l ) {
         // FIXME set the last error
         qWarning("OSQLiteDriver::open: %s", error );
         free( error );
         return false;
     }
     sqlite_create_function(m_sqlite,"rlike",2,rlikeFunc,NULL);
     return true;
 }
 
 
 /* close the db
  * sqlite closes them without
  * telling failure or success
  */
 bool OSQLiteDriver::close() {
     if (m_sqlite )
         sqlite_close( m_sqlite ), m_sqlite=0l;
-
+        free(regex_raw);
+        regex_raw=NULL;
+        regfree(&regex_c);
     return true;
 }
 
 
 /* Query */
 OSQLResult OSQLiteDriver::query( OSQLQuery* qu) {
     if ( !m_sqlite ) {
         // FIXME set error code
         OSQLResult result( OSQLResult::Failure );
         return result;
     }
     Query query;
     query.driver = this;
     char *err;
     /* SQLITE_OK 0 if return code > 0 == failure */
     if ( sqlite_exec(m_sqlite, qu->query(),&call_back, &query, &err)  > 0 ) {
         qWarning("OSQLiteDriver::query: Error while executing");
         free(err );
         // FixMe Errors
     }
 
     OSQLResult result(OSQLResult::Success,
                       query.items,
                       query.errors );