Accessing RDF term type metadata in SPARQL SELECT in mapping

[AuPath]

Is there currently a way to access RDF term type information (URI, blank node, typed literal, language-tagged literal) when executing a SPARQL SELECT query over a dataframe in a mapping file?

By “type”, I specifically refer to the type field returned in the SPARQL Query Results JSON format, e.g.:

{
  "head": {
    "vars": ["obj", "pred", "sub"]
  },
  "results": {
    "bindings": [
      {
        "obj": {
          "type": "uri",
          "value": "https://knowledge.c-innovationhub.com/cefriel/data/HardwareModel#NVIDIA_BLUEFIELD"
        }
      }
    ]
  }
}

Problem

I need to process SPARQL query results in a mapping layer where RDF terms must be handled differently depending on whether they are:

• URIs
• blank nodes
• literals (with or without datatype)
• language-tagged literals

For URIs, this is straightforward since they have a stable and recognizable structure, and we can also use helper functions such as isAbsoluteURI defined in TemplateFunctions.

However, blank nodes are more problematic because:

• Their "value" field is implementation-dependent
• Different triplestores serialize blank nodes differently
• The identifier has no semantic meaning outside the result set

For example, Oxigraph returns:

{
  "obj": {
    "type": "bnode",
    "value": "fbba96224680f2b6fadb3fff0ea508bb"
  }
}

From my understanding, the only reliable way to detect that a value is a blank node is via the "type": "bnode" field in the SPARQL JSON results, since the "value" is not stable or meaningful.

---

Extension of the issue: literals

The same issue applies to literals, where additional type metadata is required:

Typed literal

{
  "type": "literal",
  "value": "ciao",
  "datatype": "http://www.w3.org/2001/XMLSchema#string"
}

Language-tagged literal

{
  "type": "literal",
  "value": "ciao",
  "xml:lang": "it"
}

In both cases, correct downstream processing depends on correctly distinguishing:

• datatype-typed literals (datatype)
• language-tagged literals (xml:lang)
• plain literals (neither present)

---

@marioscrock, Do we currently have a way to get this information in an MTL mapping?

[marioscrock]

@AuPath you can use built-in SPARQL functionalities to add columns to the dataframe, for example

SELECT ?node
       (isIRI(?node) AS ?isIRI)
       (isBlank(?node) AS ?isBlank)
       (isLiteral(?node) AS ?isLiteral)
WHERE {
  ...
}

[AuPath]

For my very specific issue this would be a viable solution. I am not a big fan however as it means changing the sparql query itself to return information that is already present in the returned response, its just that we do not include it as part of the dataframe.

To make kind of the worst case scenario example, i am thinking of a query like this where i am also interested in the datatype and the language of the literals:

SELECT
    ?s ?p ?o

    # Subject
    (isIRI(?s)     AS ?sIsIRI)
    (isBlank(?s)   AS ?sIsBlank)
    (isLiteral(?s) AS ?sIsLiteral)
    (DATATYPE(?s)  AS ?sDatatype)
    (LANG(?s)      AS ?sLang)

    # Predicate
    (isIRI(?p)     AS ?pIsIRI)
    (isBlank(?p)   AS ?pIsBlank)
    (isLiteral(?p) AS ?pIsLiteral)
    (DATATYPE(?p)  AS ?pDatatype)
    (LANG(?p)      AS ?pLang)

    # Object
    (isIRI(?o)     AS ?oIsIRI)
    (isBlank(?o)   AS ?oIsBlank)
    (isLiteral(?o) AS ?oIsLiteral)
    (DATATYPE(?o)  AS ?oDatatype)
    (LANG(?o)      AS ?oLang)

WHERE {
...   
}

The result would be (with sample data):

s	p	o	sIsIRI	sIsBlank	sIsLiteral	sDatatype	sLang	pIsIRI	pIsBlank	pIsLiteral	pDatatype	pLang	oIsIRI	oIsBlank	oIsLiteral	oDatatype	oLang
_:b0	dao:minimumCores	"8"^^xsd:integer	❌	✅	❌	—	—	✅	❌	❌	—	—	❌	❌	✅	xsd:integer	""
_:b0	rdfs:label	"CPU Requirement"@en	❌	✅	❌	—	—	✅	❌	❌	—	—	❌	❌	✅	rdf:langString	en
_:b0	dao:recommendedCPU	cef_hw_models:Xeon6338	❌	✅	❌	—	—	✅	❌	❌	—	—	✅	❌	❌	—	—

This would be terrible to handle in an MTL mapping as it would require multiple if conditions which would worsen readability for something conceptually 'simple'.