RDF* is an extension to RDF that provides a way for one triple to refer to another triple. Another resource about RDF* is Olaf Hartig's blog entry.
Example:
<< :john foaf:name "John Smith" >> dct:source <http://example/directory> .
The part << :john foaf:name "John Smith" >>
is a triple term and refers to the triple with subject :john
, property foaf:name
and object "John Smith"
.
Triple terms can be in the subject or object position.
Jena provides support for RDF* and the related SPARQL*.
Syntax.syntaxARQ
).All this is active by default in Fuseki.
The aim is to follow the definition of RDF* as well as emerging de facto consensus in other implementations.
Storage in databases TDB1 and TDB2 is supported as of Jena 3.16.0.
RDF* syntax for triple terms is added to the parsers for Turtle, N-Triples, TriG and N-Quads.
Datasets may have graphs that have triple terms that refer to triples anywhere, not just in the same graph.
Matches for triple terms:
SELECT ?name { <<:john foaf:name ?name >> dct:source <http://example/directory> }
Insert triples terms into the default graph to record the graph source.
INSERT { <<?s ?p ?o>> dct:source <http://example/directory> } WHERE { GRAPH <http://example/directory> { ?s ?p ?o } }
These functions cause an expression error if passed the wrong type of arguments. afn:
is a prefix for <http://jena.apache.org/ARQ/function#>
.
Function | Description |
---|---|
afn:subject(?t) | Return the subject of the triple term |
afn:predicate(?t) | Return the predicate (property) of the triple term |
afn:object(?t) | Return the object of the triple term |
afn:triple(?s, ?p, ?o) | Create a triple term from s/p/o |
afn:isTriple(?t) | Return true if the argument value is a triple term |
apf:
is a prefix for <http://jena.apache.org/ARQ/property#>
.
Property Function | Description |
---|---|
<< s p o >> apf:find t . | Match the triple term. Any s , p , o , and t can be RDF terms or variables. |
apf:find
will result in all the variables being set according to the match, If t
is a variable, ?t
, it is bound to a triple term for the match of <<s p o>>
.
The syntaxes for SPARQL results from a SELECT query, application/sparql-results+json
, application/sparql-results+xml
are extended to include triple terms:
The triple term << _:b0 <http://example/p> 123 >>
is encoded, in application/sparql-results+json
as:
{ "type": "triple" , "value": { "subject": { "type": "bnode" , "value": "b0" } , "property": { "type": "uri" , "value": "http://example/p" } , "object": { "type": "literal" , "datatype": "http://www.w3.org/2001/XMLSchema#integer" , "value": "123" } }
and similarly in application/sparql-results+xml
:
<triple> <subject> <bnode>b0</bnode> </subject> <property> <uri>http://example/p</uri> </property> <object> <literal datatype="http://www.w3.org/2001/XMLSchema#integer">123</literal> </object> </triple>
RDF* triple terms are treated as Resource
to preserve the typed Model API. They occur in the subject and object positions.
A Resource
contains a Statement
object if the underlying RDF term is an RDF* triple term.
New methods include:
Statement Resource.getStatement()
Resource Model.createResource(Statement)
Resource ResourceFactory.createStatement