lib/query: Fix notmuch_threads_t to stream results rather than blocking.
authorCarl Worth <cworth@cworth.org>
Tue, 24 Nov 2009 04:18:57 +0000 (20:18 -0800)
committerCarl Worth <cworth@cworth.org>
Tue, 24 Nov 2009 04:18:57 +0000 (20:18 -0800)
Previously, notmuch_query_search_threads would do all the work, so the
caller would block until all results were processed. Now, we do the
work as we go, as the caller iterates with notmuch_threads_next. This
means that once results start coming back from "notmuch search" they
just keep continually streaming.

There's still some initial blocking before the first results appear
because the notmuch_messages_t object has the same bug (for now).

lib/query.cc

index 13bdd0a1b34b3ba944a39e22752986fef8304dea..504ab9e6b5463436a048102435992d328a74f7de 100644 (file)
@@ -38,9 +38,12 @@ struct _notmuch_messages {
 };
 
 struct _notmuch_threads {
 };
 
 struct _notmuch_threads {
-    notmuch_database_t *notmuch;
-    GPtrArray *threads;
-    unsigned int index;
+    notmuch_query_t *query;
+    GHashTable *threads;
+    notmuch_messages_t *messages;
+
+    /* This thread ID is our iterator state. */
+    const char *thread_id;
 };
 
 notmuch_query_t *
 };
 
 notmuch_query_t *
@@ -165,7 +168,7 @@ notmuch_query_search_messages (notmuch_query_t *query,
 static int
 _notmuch_threads_destructor (notmuch_threads_t *threads)
 {
 static int
 _notmuch_threads_destructor (notmuch_threads_t *threads)
 {
-    g_ptr_array_free (threads->threads, TRUE);
+    g_hash_table_unref (threads->threads);
 
     return 0;
 }
 
     return 0;
 }
@@ -174,49 +177,20 @@ notmuch_threads_t *
 notmuch_query_search_threads (notmuch_query_t *query)
 {
     notmuch_threads_t *threads;
 notmuch_query_search_threads (notmuch_query_t *query)
 {
     notmuch_threads_t *threads;
-    notmuch_thread_t *thread;
-    const char *thread_id;
-    notmuch_messages_t *messages;
-    notmuch_message_t *message;
-    GHashTable *seen;
 
     threads = talloc (query, notmuch_threads_t);
     if (threads == NULL)
        return NULL;
 
 
     threads = talloc (query, notmuch_threads_t);
     if (threads == NULL)
        return NULL;
 
-    threads->notmuch = query->notmuch;
-    threads->threads = g_ptr_array_new ();
-    threads->index = 0;
-
-    talloc_set_destructor (threads, _notmuch_threads_destructor);
-
-    seen = g_hash_table_new_full (g_str_hash, g_str_equal,
-                                 free, NULL);
-
-    for (messages = notmuch_query_search_messages (query, 0, -1);
-        notmuch_messages_has_more (messages);
-        notmuch_messages_advance (messages))
-    {
-       message = notmuch_messages_get (messages);
-
-       thread_id = notmuch_message_get_thread_id (message);
-
-       if (! g_hash_table_lookup_extended (seen,
-                                           thread_id, NULL,
-                                           (void **) &thread))
-       {
-           thread = _notmuch_thread_create (query, query->notmuch,
-                                            thread_id,
-                                            query->query_string);
-           g_ptr_array_add (threads->threads, thread);
+    threads->query = query;
+    threads->threads = g_hash_table_new_full (g_str_hash, g_str_equal,
+                                             free, NULL);
 
 
-           g_hash_table_insert (seen, xstrdup (thread_id), thread);
-       }
+    threads->messages = notmuch_query_search_messages (query, 0, -1);
 
 
-       notmuch_message_destroy (message);
-    }
+    threads->thread_id = NULL;
 
 
-    g_hash_table_unref (seen);
+    talloc_set_destructor (threads, _notmuch_threads_destructor);
 
     return threads;
 }
 
     return threads;
 }
@@ -230,7 +204,32 @@ notmuch_query_destroy (notmuch_query_t *query)
 notmuch_bool_t
 notmuch_threads_has_more (notmuch_threads_t *threads)
 {
 notmuch_bool_t
 notmuch_threads_has_more (notmuch_threads_t *threads)
 {
-    return (threads->index < threads->threads->len);
+    notmuch_message_t *message;
+
+    if (threads->thread_id)
+       return TRUE;
+
+    while (notmuch_messages_has_more (threads->messages))
+    {
+       message = notmuch_messages_get (threads->messages);
+
+       threads->thread_id = notmuch_message_get_thread_id (message);
+
+       if (! g_hash_table_lookup_extended (threads->threads,
+                                           threads->thread_id,
+                                           NULL, NULL))
+       {
+           g_hash_table_insert (threads->threads,
+                                xstrdup (threads->thread_id), NULL);
+           notmuch_messages_advance (threads->messages);
+           return TRUE;
+       }
+
+       notmuch_messages_advance (threads->messages);
+    }
+
+    threads->thread_id = NULL;
+    return FALSE;
 }
 
 notmuch_thread_t *
 }
 
 notmuch_thread_t *
@@ -239,14 +238,16 @@ notmuch_threads_get (notmuch_threads_t *threads)
     if (! notmuch_threads_has_more (threads))
        return NULL;
 
     if (! notmuch_threads_has_more (threads))
        return NULL;
 
-    return (notmuch_thread_t *) g_ptr_array_index (threads->threads,
-                                                  threads->index);
+    return _notmuch_thread_create (threads->query,
+                                  threads->query->notmuch,
+                                  threads->thread_id,
+                                  threads->query->query_string);
 }
 
 void
 notmuch_threads_advance (notmuch_threads_t *threads)
 {
 }
 
 void
 notmuch_threads_advance (notmuch_threads_t *threads)
 {
-    threads->index++;
+    threads->thread_id = NULL;
 }
 
 void
 }
 
 void