* Add indexing on source, to speedup saving a particular source as well as
  rdf_retractall(_,_,_,Src).

* Add indexing for rdf(+,+,+)?  Might speedup loading (duplicate adiminstration).

* Document hookable rdf_load/2

* Allow for concurrent transactions.

    - Starting a transaction obtains no lock
    - Each thread has its own transaction queue
	- If a thread that has a transaction starts one, this (still)
	  creates a nested transaction.
    - Only if a transaction is about to be comitted, it obtains a
      write-lock, plays the queue and releases the write lock.

  What goes wrong now?

    - If a transaction does repeated read queries, it may see different
      data during its read actions.
	- This could be avoided using generation-stamps, similar to Prolog
    - How can queued actions interfere with each other?
	- A: S0 --> S1
	- B: S0 --> S2

  Asynchronous write is generally possible, unless it requires a re-hash.

    - Writes must remain sequentially (for the persistency and callback
      assumptions).
    - Can we avoid the *need* for a re-hash?  This would require multiple
      queries if predicate clouds are joined.