RDF Base IRIs not working (hashtag2765)

[vikramsubramanian]

According to the [RDF Turtle file specification]( some IRIs can be specified as relative IRIs against a base IRI. The [specification of relative IRIs]( is as follows:

[IRIs]( may be written as relative or absolute IRIs or prefixed names. Relative and absolute IRIs are enclosed in '<' and '>' and may contain [numeric escape sequences]( (described below). For example <

Relative IRIs like are resolved relative to the current base IRI. A new base IRI can be defined using the ' or 'BASE' directive. Specifics of this operation are defined in [section 6.3 IRI References](

So for example, if you ingest the triples in the example in the specification:

 < .
 rdf: < .
 rdfs: < .
 foaf: < .
 rel: < .

<hashtaggreen-goblin>
    rel:enemyOf <hashtagspiderman> ;
    a foaf:Person ;    hashtag in the context of the Marvel universe
    foaf:name "Green Goblin" .

<hashtagspiderman>
    rel:enemyOf <hashtaggreen-goblin> ;
    a foaf:Person ;
    foaf:name "Spiderman", "Человек-паук" .

You would get for , " We currently ingest these as "hashtaggreen-goblin". )

[mayil-ai[bot]]

Summary: Issue with resolving relative IRIs against a base IRI in RDF Turtle files.

Possible Solution

The issue described pertains to the incorrect resolution of relative IRIs in RDF Turtle files. The expected behavior is that relative IRIs such as <hashtaggreen-goblin> and <hashtagspiderman> should be resolved against a base IRI, but they are currently being ingested incorrectly without resolution.

To address this issue, the following solution should be implemented:

• Ensure that the read_IRIREF function in third_party/serd/src/n3.c correctly handles relative IRIs by resolving them against the current base IRI.
• Modify the read_IRIREF function to check if the IRI is relative. If it is, resolve it using the base IRI before adding it to the node.
• Use the serd_uri_resolve function from third_party/serd/src/uri.c to resolve the relative IRI against the base IRI.
• Update the RdfReader::prefixHandle function in src/processor/operator/persistent/reader/rdf/rdf_reader.cpp to store the base IRI when the BASE directive is encountered in the RDF Turtle file.
• Ensure that the base IRI is used in the read_IRIREF function to resolve relative IRIs correctly.

Here is a pseudo-code outline of the changes to be made in the read_IRIREF function:

static SerdStatus
read_IRIREF(SerdReader* const reader, Ref* const dest) {
  // ... existing code ...

  // Check if the IRI is relative
  if (is_relative_iri(reader, *dest)) {
    // Resolve the relative IRI against the base IRI
    SerdURI resolved_uri;
    serd_uri_resolve(reader->base_iri, *dest, &resolved_uri);
    // Replace *dest with the resolved URI
    *dest = push_node_with_resolved_uri(reader, &resolved_uri);
  }

  // ... existing code ...
}

Additionally, ensure that the RdfReader::prefixHandle function correctly updates the base IRI when the BASE directive is encountered:

SerdStatus RdfReader::prefixHandle(void* handle, const SerdNode* /*name*/, const SerdNode* uri) {
  auto reader = reinterpret_cast<RdfReader*>(handle);
  if (is_base_directive(uri)) {
    // Update the base IRI
    reader->base_iri = reinterpret_cast<const char*>(uri->buf);
  }
  return SERD_SUCCESS;
}

Make sure to test the changes with RDF Turtle files containing relative IRIs to verify that they are now being resolved correctly against the base IRI.

Code snippets to check

• third_party/serd/src/n3.c

  The 'read_base' function is responsible for handling the 'BASE' directive which is relevant to resolving relative IRIs against a base IRI.

• third_party/serd/src/uri.c

  The 'serd_uri_serialise_relative' function serializes relative URIs, which is directly related to the issue of RDF Base IRIs not working correctly.

• third_party/serd/src/writer.c

  The 'serd_writer_set_base_uri' function sets the base URI in the writer, which could be involved in the resolution of relative IRIs.

• third_party/serd/src/node.c

  The 'serd_node_new_relative_uri' function creates a new node for a relative URI, which is relevant to the issue of handling relative IRIs.