rdf_pl.pl

:- module(rdf_pl,
	  [ rdf/3,				% ?S,?P,?O
	    rdf/4,				% ?S,?P,?O,?G
	    rdf/5,				% ?S,?P,?O,?G,?Gen
	    rdf_subject/1,			% ?S
	    rdf_current_predicate/1,		% ?P
	    rdf_assert/4,			% +S,+P,+O,+G
	    rdf_assert/3,			% +S,+P,+O
	    rdf_retractall/3,			% ?S,?P,?O
	    rdf_retractall/4,			% ?S,?P,?O,?G
	    rdf_reset_db/0,
	    rdf_statistics/1
	  ]).

/** <module> Create random graphs

Operations:
	- Create a property
	- Add/Del triples for a property
	- Add/Del a subPropertyOf relation
	  - Extend a tree
	  - Make multiple inheritance in a tree
	  - Create cycle in a tree

Shadow DB is a graph. We do not need literals. Triples are represented
as

	triple(S,P,O,G,Born,Id)
	died(Id, Died)
*/

:- dynamic
	subject/1,
	predicate/1,
	triple/6,
	died/2,
	triple_id/1,
	generation/1.

rdf_reset_db :-
	retractall(subject(_)),
	retractall(predicate(_)),
	retractall(triple(_,_,_,_,_,_)),
	retractall(died(_,_)),
	retractall(triple_id(_)),
	retractall(generation(_)).

rdf_statistics(triples(Count)) :-
	predicate_property(triple(_,_,_,_,_,_), number_of_clauses(Count)).

rdf_assert(S,P,O) :-
	rdf_assert(S,P,O,user).

rdf_assert(S,P,O,G) :-
	with_mutex(triple_db, t_assert_(S,P,O,G)).


rdf(S,P,O) :-
	rdf(S,P,O,_).

rdf(S,P,O,G) :-
	generation(Gen),
	rdf(S,P,O,G,Gen).

rdf(S,P,O,G,Gen) :-
	rdf(S,P,O,G,Gen,_).

rdf(S,P,O,G,Gen,Id) :-
	triple(S,P,O,G,Born,Id),
	Gen >= Born,
	\+ (  died(Id, Died),
	      Gen >= Died
	   ).

rdf_subject(S) :-
	subject(S).

rdf_current_predicate(S) :-
	predicate(S).

rdf_retractall(S,P,O) :-
	rdf_retractall(S,P,O,_).

rdf_retractall(S,P,O,G) :-
	generation(Gen),
	with_mutex(triples,
		   (   rdf(S,P,O,G,Gen,Id),
		       next_generation(Died),
		       assertz(died(Id, Died)),
		       fail
		   ;   true
		   )).

t_assert_(S,P,O,G) :-
	next_triple_id(Id),
	next_generation(Gen),
	assertz(triple(S,P,O,G,Gen,Id)),
	assert_subject(S),
	assert_predicate(P).

next_triple_id(Id) :-
	retract(triple_id(Id0)), !,
	Id is Id0+1,
	assertz(triple_id(Id)).
next_triple_id(1) :-
	assertz(triple_id(1)).

next_generation(Gen) :-
	retract(generation(Gen0)), !,
	Gen is Gen0+1,
	assertz(generation(Gen)).
next_generation(1) :-
	assertz(generation(1)).

assert_subject(S) :-
	subject(S), !.
assert_subject(S) :-
	assertz(subject(S)).

assert_predicate(P) :-
	predicate(P), !.
assert_predicate(P) :-
	assertz(predicate(P)).