Re: Q: ISSUE-41 bNode semantics

On 18 May 2011, at 21:22, Enrico Franconi wrote:
> (1) you have no evidence that "the semantics of RDF offers no construct that adequately covers this"

I do have evidence:

I read it all and nothing in there works for this.

Burden of proof is on you now I'd say ;-)

> (2) but given this, you then decide to deal anyway with NULL values, and you give a (already shown incorrect) mapping for them?

Perhaps incomplete, but not incorrect.

> When a future WG will fix this, the change will be most likely non backward compatible, since now you are taking a non-motivated choice for the mapping of NULLs. And this is bad.

As long as we translate the non-null parts correctly, our translation is correct. It may not be complete because the presence of a null may give some extra information that we do not capture. However, if some clever spirit in the future should find some way of squeezing that extra information into RDF triples, then these extra triples can always be added without breaking backwards compatibility. RDF is monotonic.

> If the majority of this WG does not want to explore the correctness of the mapping for NULL values, them my proposal would be something along the lines:
> "Note: if a relational database contains NULL values, then the direct mapping is not applicable. This case is postponed for consideration to a future WG."

I repeat: Not mapping nulls may be incomplete, but not incorrect. Punting on the NULL cells doesn't mean that we have to punt on the entire DB.

> I propose to translate a NULL value as a special constant from a special datatype, and to understand how SPARQL 1.0 queries should be modified in order to behave properly in presence of RDF data coming from a direct mapping of a RDB with NULL values. My guess is that it is enough to enrich the BGP part with a conjunct NOT-EQUAL(X,'NULL') [pardon my naive syntax here] for each joined (namely repeated in the BGP) variable X, so we remain in pure SPARQL 1.0.

I'll not comment on charter scope here, I'll leave that to others.

You talk about changing SPARQL. But let me just say that you'd have to go deeper than that.

If we have this:

  <Alice> <name> "NULL"^^rdb2rdf:NULL .
  <Bob>   <name> "NULL"^^rdb2rdf:NULL .

then from RDF Semantics it follows that <Alice> and <Bob> have the same name. A constant is a constant, that's how datatypes work in RDF and you can't do anything about that unless you are prepared to change the formal semantics. If you need a walkthrough of the spec to see why this is true, let me know.

It's not just SPARQL that's built on that foundation, but also OWL2 and RIF. Are you prepared to change them as well?


Received on Wednesday, 18 May 2011 23:10:15 UTC