From: david@tethera.net
To: notmuch@notmuchmail.org
Date: Tue,  8 Dec 2009 18:07:43 -0400
Message-Id: <1260310063-11731-1-git-send-email-david@tethera.net>
In-Reply-To: <87ws0x23r8.fsf@yoom.home.cworth.org>
References: <87ws0x23r8.fsf@yoom.home.cworth.org>
Cc: David Bremner <bremner@unb.ca>
Subject: [notmuch] [PATCH] notmuch-restore.c: only update tags for messages
	that differ from dump file.
Precedence: list

From: David Bremner <bremner@unb.ca>

The main feature of this patch is that it compares the list of current
tags on a message with those read by restore. Only if the two lists
differ is the tag list in the message replaced.  In my experiments this leads to
a large performance improvement.

Since I had to rewrite the parsing of tags from the dump file anyway
to keep a list of tags (in case they should be written to the
database), I decided to make it a bit more robust. It sorts the
incoming tags (it is critical for the comparison of the two tag lists
that they are both sorted), and allows arbitrary whitespace (as
determined by "isspace") between tags.

The patch allocates a temporary array to keep track of the current
list of tags using talloc_array and grows it as neccesary using
talloc_realloc.
---

This is posting 3 of the patch. The second version fixed a bug.  This
version replaces calloc/realloc with talloc equivalents, prettifies
the comparison function for qsort, reindents, and adds a bunch of
whitespace.

 notmuch-restore.c |   98 +++++++++++++++++++++++++++++++++++++++++++----------
 1 files changed, 80 insertions(+), 18 deletions(-)

diff --git a/notmuch-restore.c b/notmuch-restore.c
index 1b9598d..818bd15 100644
--- a/notmuch-restore.c
+++ b/notmuch-restore.c
@@ -19,9 +19,22 @@
  */
 
 #include "notmuch-client.h"
+#include <stdlib.h>
+#include <ctype.h>
+
+#define DEFAULT_TAG_ARRAY_SIZE 2
+
+static int 
+strcmp_for_qsort (const void *ptr1, const void *ptr2)
+{
+    char * const * str1_p = ptr1;
+    char * const * str2_p = ptr2;
+
+    return strcmp(*str1_p, *str2_p);
+}
 
 int
-notmuch_restore_command (unused (void *ctx), int argc, char *argv[])
+notmuch_restore_command (void *ctx, int argc, char *argv[])
 {
     notmuch_config_t *config;
     notmuch_database_t *notmuch;
@@ -31,6 +44,8 @@ notmuch_restore_command (unused (void *ctx), int argc, char *argv[])
     ssize_t line_len;
     regex_t regex;
     int rerr;
+    char **tag_array = NULL;
+    int tag_array_size = DEFAULT_TAG_ARRAY_SIZE;
 
     config = notmuch_config_open (ctx, NULL, NULL);
     if (config == NULL)
@@ -61,11 +76,21 @@ notmuch_restore_command (unused (void *ctx), int argc, char *argv[])
 	      "^([^ ]+) \\(([^)]*)\\)$",
 	      REG_EXTENDED);
 
+    /* Make an array of pointers to point to individual tokens */
+    tag_array = talloc_array (ctx, char *, tag_array_size);
+    if  (!tag_array) {
+	fprintf (stderr, "fatal: overflow in talloc_array");
+	exit(1);
+    }
+    
     while ((line_len = getline (&line, &line_size, input)) != -1) {
 	regmatch_t match[3];
-	char *message_id, *tags, *tag, *next;
+	char *message_id, *tags,  *next;
 	notmuch_message_t *message;
 	notmuch_status_t status;
+	int tag_count;
+	notmuch_tags_t *tag_list;
+	int i;
 
 	chomp_newline (line);
 
@@ -89,26 +114,61 @@ notmuch_restore_command (unused (void *ctx), int argc, char *argv[])
 	    goto NEXT_LINE;
 	}
 
-	notmuch_message_freeze (message);
-
-	notmuch_message_remove_all_tags (message);
-
 	next = tags;
-	while (next) {
-	    tag = strsep (&next, " ");
-	    if (*tag == '\0')
-		continue;
-	    status = notmuch_message_add_tag (message, tag);
-	    if (status) {
-		fprintf (stderr,
-			 "Error applying tag %s to message %s:\n",
-			 tag, message_id);
-		fprintf (stderr, "%s\n",
-			 notmuch_status_to_string (status));
+	tag_count = 0;
+	while (*next) {
+	    while (*next && isspace(*next))
+		next++;
+	    if (*next) {
+		while (tag_count >= tag_array_size) {
+		    tag_array_size *= 2;
+		    tag_array = talloc_realloc (ctx, tag_array, char *, 
+						tag_array_size);
+		    if  (!tag_array) {
+			fprintf (stderr, "fatal: overflow in talloc_realloc");
+			exit(1);
+		    }
+		} 
+		tag_array[tag_count] = next;
+		tag_count++;
 	    }
+	    while (*next && !isspace(*next))
+		next++;
+	    if (*next) {
+		*next = '\0';
+		next++;
+	    }
+	}
+
+	qsort(tag_array,tag_count,sizeof(char*),strcmp_for_qsort);
+	
+	tag_list = notmuch_message_get_tags (message);
+	i = 0;
+	while (notmuch_tags_has_more (tag_list) && i < tag_count &&
+	       (strcmp(notmuch_tags_get (tag_list),tag_array[i]) == 0))
+	{
+	    notmuch_tags_advance (tag_list);
+	    i++;
 	}
 
-	notmuch_message_thaw (message);
+	/* the only success condition is for the tag list comparison is to run
+	   off the end of both lists at the same time */
+	if (notmuch_tags_has_more (tag_list) || i < tag_count ){
+	    notmuch_message_freeze (message);
+	    notmuch_message_remove_all_tags (message);
+
+	    for (i=0; i < tag_count; i++) {
+		status = notmuch_message_add_tag (message, tag_array[i]);
+		if (status) {
+		    fprintf (stderr,
+			     "Error applying tag %s to message %s:\n",
+			     tag_array[i], message_id);
+		    fprintf (stderr, "%s\n",
+			     notmuch_status_to_string (status));
+		}
+	    }
+	    notmuch_message_thaw (message);
+	}
 	notmuch_message_destroy (message);
       NEXT_LINE:
 	free (message_id);
@@ -120,6 +180,8 @@ notmuch_restore_command (unused (void *ctx), int argc, char *argv[])
     if (line)
 	free (line);
 
+    talloc_free (tag_array);
+
     notmuch_database_close (notmuch);
     if (input != stdin)
 	fclose (input);
-- 
1.6.5.3