RDF 1.1, SPARQL and SWI7 literal handling

[JanWielemaker]

Status

Literal handling in rdf_db is outdated and not practical. Currently, literals have the form

• literal(Atom)
• literal(lang(LangAtom, TextAtom))
• literal(type(TypeIRI, Value), where Value is one of
  • Atom representing lexical form. This is the default when parsing a file
  • XML DOM term for XMLLiteral
  • An integer or float or general Prolog term can be asserted using rdf_assert/3,4

All literals are sorted, but the sorting has little relation to the SPARQL defined ordering. This implies we cannot optimize SPARQL queries that use comparison operators.

Issues

• RDF 1.1 abandoned plain literals. We should do that too. That is pretty easy by changing the parsers. We can also change rdf_assert/3,4 to assert a plain literal as xsd:string. That might be better?
• Dealing with literals is a nuisance in Prolog if you are interested in the value space, notably for numerical value.
• Steadfastness requirements are broken in many places. Both for literal handling and for the graph argument.

  Ideal

• Create steadfast rdf/3,4
• Should rdf_assert(S,P,O), rdf(S,P,O) always be true?
• What about rdf_assert(S,P,O), rdf(S,P,X), X=O?

By type:

• Resources as atoms work fine.

• The 4th argument must be the graph (an IRI, atom). We need a new rdf/5 (probably with a different name to query <S,P,O,G,Line>. The Line has different meanings:

  • Originally, Line was the line in the file from which the triple was loaded.
  • The library(rdf_persistency) uses `Line' as time stamp to correlate transactions on different graphs.
  • Caching applications might use it for last access, etc. Possibly we should separate that.

  What about saying that a triple is identified by <S,P,O,G> and have a predicate rdf_triple_property(S,P,O,G,Property) to query additional properties (last access, line, etc.)?

• Literals ideally have a canonical form that is comfortable to work with. Possibly
  • Text@Lang
  • Value^^Type Where Text can be a Prolog string. Value depends on type. Types in the profile are mapped to Prolog native values, while others use a Prolog string.

In retrospect, I think the value of an XMLLiteral should be the (canonical) XML serialization rather than the DOM tree. Other types:

• All XML Schema integer types are mapped to Prolog integers
• XML Schema float and double are mapped to Prolog double (64-bit IEEE)
• XML Decimals can either be mapped to floats or rationals. Depending on a flag? Should we give decimals a place in SWI-Prolog, representing them as a tuple <Int, DecimalPointLocation>? E.g., 10.345 is <10345,3>?
• Time formats are hard. Options:
  • A compound or dict containing the components. Advantage is that we can add functions to the dict.
  • A stamp indicating the start, where the duration is defined by the type. E.g. 1970^^xsd:gYear is represented as 0.
  • A tuple (Start,Length) indicating a duration?
  • Or, after all, have e.g. "03-19"^^xsd:gMonthDay and have a library dealing with them? After all, AFAIK, SPARQL defines different data/time types not to be comparable and they all compare as expected when compared alphabetically. Notably XML Schema defines min/max|inclusive/exclusive on them.

    Compatibility

• Have a new library(rdf) that provides the new API and rdf_db that provides the old?
• Use alternative file search paths to select libraries using the old API or the new API?

[wouterbeek]

Great proposal! Improving literal assertion and named graph retrieval will make Semweb more versatile as well as more compliant with RDF 1.1. Some comments:

Storing literals using values

In Semweb the following currently asserts exactly one triple, disregarding the datatype entirely:

?- rdf_assert(rdf:s, rdf:p, literal(1)).
?- rdf_assert(rdf:s, rdf:p, literal(type(xsd:integer,1))).
?- rdf_assert(rdf:s, rdf:p, literal(type(xsd:nonNegativeInteger,1))).

Mixing lexical forms and values

Currently Semweb does not correctly allow some literals to be asserted using lexical expressions and some literals to be asserted using values.

The following should assert exactly one triple, since lexical expression '1' maps to value 1 according to the lexical-to-value mapping of datatype XSD integer.

?- rdf_assert(rdf:s, rdf:p, literal(type(xsd:integer,1))).
?- rdf_assert(rdf:s, rdf:p, literal(type(xsd:integer,'1'))).

Result:

?- rdf(S, P, O).
S = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#s',
P = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#p',
O = literal(type('http://www.w3.org/2001/XMLSchema#integer', 1)) ;
S = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#s',
P = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#p',
O = literal(type('http://www.w3.org/2001/XMLSchema#integer', '1')).

Simple / plain literals

The terms "simple literal" and "plain literal" have both been dropped in RDF 1.1. The former are now XSD strings. Some of the latter are now XSD strings and some of the latter are now RDF language-tagged strings.

[wouterbeek]

I tried to incorporate these point into the wiki: https://github.com/SWI-Prolog/packages-semweb/wiki/Proposal-for-Semweb-library-redesign

@JanWielemaker Can you check whether all your points were sufficiently included and then close this issue?