33 lines
		
	
	
		
			1.1 KiB
		
	
	
	
		
			Plaintext
		
	
	
	
	
	
		
		
			
		
	
	
			33 lines
		
	
	
		
			1.1 KiB
		
	
	
	
		
			Plaintext
		
	
	
	
	
	
| 
								 | 
							
								* 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.
							 | 
						||
| 
								 | 
							
								
							 |