This wiki has been archived and is now read-only.

LDP PATCH Proposals

From Linked Data Platform
Jump to: navigation, search

1 TurtlePatch 2011

Link: http://www.w3.org/2001/sw/wiki/TurtlePatch

Author: Sandro (circa 2011)

Summary: subset of SPARQL Update with INSERT and DELETE clauses.


PREFIX foaf <http://xmlns.com/foaf/0.1/>
PREFIX s <http://www.w3.org/2000/01/rdf-schema#>
  <http://www.w3.org/People/Berners-Lee/card#i> foaf:mbox <mailto:timbl@w3.org>
  <http://www.w3.org/People/Berners-Lee/card#i> foaf:mbox <mailto:timbl@hushmail.com>
  <http://www.w3.org/People/Berners-Lee/card> s:comment "This is my general description of myself.\n\nI try to keep data here up to date and it should be considered authoritative."


  • can be implemented using full SPARQL implementation
  • easy to implement from scratch (parser + runtime)


  • no support for bnodes


  • implemented in Banana-RDF


  • Sandro talked about "TurtlePatch plus variables" but this is not in the spec
  • James Leigh argues that
with blank node identifiers [through skolemization], the above solution handles blank nodes quite well, IMHO, without any of the NP problems other solutions have

2 RDF Patch

Link: http://afs.github.io/rdf-patch/

Champion: Andy Seaborne

Summary: diffs for RDF dataset

Example: (A is for Add and D for Delete)

A <http://example.org/alice> <http://xmlns.com/foaf/0.1/name> "Robert" .
A <http://example.org/bob> <http://xmlns.com/foaf/0.1/knows> <http://example/alice> .
A <http://example.org/alice> <http://xmlns.com/foaf/0.1/name> "Alice" .
D <http://example.org/bob> <http://xmlns.com/foaf/0.1/name> "Robert" .
A <http://example.org/bob> <http://xmlns.com/foaf/0.1/name> "Bob" .


  • easy to implement from scratch (parser + runtime)


  • specified for an RDF dataset, not an LDPR
  • blank nodes are system dependant, so not well specified in the case of LDP. Skolemization?

Remark: actually pretty much the same than TurtlePatch, but it feels like it was written for a different use-case.

3 EricP's proposal

Champion: EricP

Summary: SPARQL subset with DELETE, INSERT and WHERE clause. The WHERE clause is restricted to a simple BGP with no var-predicates (see grammar).


PREFIX foaf: <http://xmlns.com/foaf/0.1/> DELETE { ?s foaf:name "Alex" } INSERT { ?s foaf:name "Alexandre" } WHERE { ?s foaf:name "Alex" }


PREFIX foaf: <http://xmlns.com/foaf/0.1/>
DELETE { ?bob foaf:knows ?alice }
INSERT { ?bob foaf:knows ?eve ; foaf:trusts ?eve }
    ?bob foaf:knows ?alice .
    ?alice foaf:mbox <mailto:alice@example.org> .
    ?eve foaf:mbox <mailto:eve@example.org>

which involves two disconnected query patterns.


  • can be implemented using full SPARQL implementation
  • in practice, still easy enough to implement from scratch (parser + runtime)
  • can be used to reach some bnodes


  • some queries can be NP-complete, e.g.

    ?a foaf:knows ?b . ?b foaf:knows ?c . ?c foaf:knows ?d . d foaf:knows ?e .


  • implemented in Banana-RDF

Remark: one could argue that in practice, LDPRs are not supposed to be crazy big, and that most queries won't end up with the worst-case complexity.

4 EricP's proposal + nailed graph

Champion: TimBL

Summary: same as previous one, but the BGP returns a single matching node. Some additional constraints are put on the query: nailed nodes and IFP (Inverse Functional Property).


  • can be implemented using full SPARQL implementation
  • in practice, still easy enough to implement from scratch (parser + runtime)
  • can be used to reach some bnodes
  • expected not to be NP-complete


  • we further restrain the number of bnodes that can be matched. Shouldn't be an issue in practice.


  • I implemented a similar restriction in Banana-RDF when the BGP is a tree pattern.
  • TimBL told me that Tabulator already implements that approach.

4.1 Definition of a nailed graph (TimBL)

A nailed graph is a graph for which every node is nailed.

A nailed node is one which has a URI or is connected to a nailed by a inverse functional or function property arc of the appropriate direction.

  • if n has a URI then {} nails n.
  • if p is IFP and W(m) nails m then { n p m } U W(m) nails n.
  • if p is FP and W(m) nails m then { m p n } U W(m) nails n.

A nailed graph is a graph in which every node n is nailed.

When doing a patch the WHERE clause is the union of the nailing graphs of the variables which have been inserted to match bnodes.

[ Sandro comment: I'd change this to be talking about graph shapes, where "FP" is the property of a predicate occurring in the graph only in 1-to-1 or many-to-1 configurations, rather than the actual OWL notion of a Functional Property, which isn't actually about the graph itself. ]

5 Joe Presbrey's PATCH

Champion: Joe Presbrey

Summary: format is Turtle. For each triple { s p o }, { s p ANY } is deleted and { s p o } is added. His implementation forbids the use of blank nodes.


  • super easy


  • can't have { s p o1; o2 } anymore
  • can't delete
  • no bnodes


  • Joe implemented this approach in one of his projects (I guess either data.fm or ldpy)

6 Pierre-Antoine Champin's RDF-PATCH

Link: https://github.com/pchampin/rdfpatch

Champion: Pierre-Antoine Champin

Summary: extends RDF Patch with property paths, rdf:list shortcuts. Binding variables is mentionned but not yet specified.

Example: (more examples here)

  1. example of complex path

A <http://champin.net/#pa> -<http://xmlns.com/foaf/0.1/member>/<http://xmlns.com/foaf/0.1/homepage> <http://www.univ-lyon1.fr/> . A "Andy Seaborne" -<http://xmlns.com/foaf/0.1/name>/<http://xmlns.com/foaf/0.1/nick> "AndyS" .


  • more capabilities than Andy's version
  • native support for rdf:list
  • can access some bnodes through URI + property path (without knowing label)


  • relies on skolemization for general handling of bnodes
  • not a sybset of SPARQL Update (but easy syntax)



Link: http://websub.org/wiki/GRUF

Author: Sandro (circa 2010)

Summary: A namable-blank-nodes custom format, with list operations


  • Efficient


  • Like rdf-patch, it's not exactly RDF

8 TurtlePatch 2014

Revision of TurtlePatch (Sandro, 2014) to say: use virtual Skolemization. That is, when you GET or PATCH a resource through application/turtlepatch, you see/manipulate a Skolemized view. This solves the blank node problem.