Excerpts from dm-list-email-notmuch's message of 2014-04-10 17:31:04 +0200:
> Gaute Hope <e...@gaute.vetsj.com> writes:
>
> >> A better approach would be to add a new "modtime" xapian value that is
> >> updated whenever the tags or any other terms (such as XFDIRENTRY) are
> >> added to or deleted from a docid.  If it's a Xapian value, rather than a
> >> term, then modtime will be queriable just like date, allowing multiple
> >> applications to query all docids modified since the last time they ran.
> >>
> >> [... snip]
> >
> > This could also solve it, and probably have more uses. I don't quite see
> > how the opposite problem (for my use case) can be solved by this without
> > using a 'localchange' tag. This is to sync tag to maildir sync, when a
> > new tag has been added (by e.g. a user interaction in a client) it needs
> > to be copied to the maildir, if it is not done in the same go a
> > different application won't know whether the change was local or remote.
> > How did you solve this?
>
> Why don't you just set maildir.synchronize_flags=true?  When I
> synchronize mail across machines, I start by concurrently running
> "notmuch new" on both the local and remote machines, which picks up all
> the changed maildir flags.  Then I synchronize the mail and the tags
> between the two maildirs.  If maildir.synchronize=true, then atomically
> with setting the new tags I call notmuch_message_tags_to_maildir_flags()
> to sync the new tags to the maildir.

I am talking about syncing tags to a maildir _folder_, not flags. It
could be implemented as maildir.synchronize is now, but it would be a
larger feature which could work in a lot of different ways.

> The maildir flags question seems kind of independent of what we are
> talking about, which is just having an incremental way of examining the
> database.  Right now, I have to scan everything to find tags that have
> changed since the last synchronization event.  If I had modtime (or
> really it should be called "ctime", like inode change time), then I
> could look at only the few messages that changed, and it would probably
> shave 250msec off polling new mail for a 100,000-message maildir.
>
> Note you can't use the file system ctime/mtime because the file system
> may have changed since the last time you ran notmuch new.

If you have a unreliable clock or use a badly configured system you
could risk detecting changes in the case where application time stamp is
set in the future, a mod time now. Then the app won't know there has
been a change. The same could happen if the clock is in the past, and
the modtime is set, the clock is updated and the app won't know there
has been a change.

The only way to know is to do a full scan of the entire db. This could
be very expansive, and comparable to initial indexing, for some actions.

You would not necessarily, or reliably, be able to detect this.

With an internal tick this wouldn't be an issue.

> > I would suggest using a Xapian- or Index-time which gets a tick
> > everytime a modification is made to the index.
>
> Exactly.  It could be a tick, or just the current time of day if your
> clock does not go backwards.  (I'd be willing to do a full scan if the
> clock ever goes backwards.)  The advantage of time is that you don't
> have to synchronously update some counter.
>
> > Atomic operations could operate on the same time in case this
> > distinction turns out to be useful. Perhaps something like this
> > already exists in Xapian?
>
> I don't think it's important for atomic operations to have the same
> timestamp.  All that's important is that you be able to diff the
> database between the last time you scanned it.

Yeah, it is not necessary for anything I am planning on doing, but it
would be a way for other apps to know that a set of changes were done at
the same time.

> > This way clock skew, clock resolution (lots of operations happening in
> > the same second, msec or nanosec) problems won't be an issue. The crux
> > will be to make sure all write-operations trigger a tick on the
> > indextime.
>
> Clock skew is not really an issue.  It takes years to amass hundreds of
> thousands of email messages.  So adding 5 minutes of slop is not a big
> deal--you'll just scan a few messages needlessly.

Yes, but you risk missing changes without knowing. That is an issue for
my use case.


> Making sure the write-operations update the time should be easy.  Most
> or all of the changes are probably funneled through
> _notmuch_message_sync.  Worst case, there are only 9 places in the
> source code that make use of a Xapian:WritableDatabase, so I'm pretty
> confident total changes wouldn't be much more than 50 lines of code.

Yes :)

> I would do it myself if there were any kind of indication that such a
> change could be upstreamed.  I brought this up in January, 2011, and
> didn't get a huge amount of interest in the ctime idea.  But I was also
> a lot less focused on what I needed.  Now that I have a working
> distributed setup and am actually using notmuch for my mail, I have a
> much better understanding of what is needed.

Would be great if it could be included.. I guess a comment from
one/some of the notmuch-gurus could clarify?


- gaute
_______________________________________________
notmuch mailing list
notmuch@notmuchmail.org
http://notmuchmail.org/mailman/listinfo/notmuch

Reply via email to