MarkLogic 9 Product Documentation

Semantics Developer's Guide — Chapter 1

Storing RDF Triples in MarkLogic

When you load RDF triples into MarkLogic, the triples are stored in MarkLogic-managed XML documents. You can load triples from a document using an RDF serialization, such as Turtle or N-Triple. For example:

<http://example.org/dir/js> <http://xmlns.com/foaf/0.1/firstname> "John" .
<http://example.org/dir/js> <http://xmlns.com/foaf/0.1/lastname> "Smith" .
<http://example.org/dir/js> <http://xmlns.com/foaf/0.1/knows> "Jane Smith" .

For more examples of RDF formats, see Example RDF Formats.

The triples in this example are stored in MarkLogic as XML documents, with sem:triples as the document root. These are managed triples because they have a document root element of sem:triples.

<?xml version="1.0" encoding="UTF-8"?>
<sem:triples xmlns:sem="http://marklogic.com/semantics">
 <sem:triple>
  <sem:subject>http://example.org/dir/js</sem:subject>
  <sem:predicate>http://xmlns.com/foaf/0.1/firstname</sem:predicate>
  <sem:object datatype="http://www.w3.org/2001/XMLSchema#string">John
  </sem:object>
 </sem:triple>
 <sem:triple>
  <sem:subject>http://example.org/dir/js</sem:subject>
  <sem:predicate>http://xmlns.com/foaf/0.1/lastname</sem:predicate> 
  <sem:object datatype="http://www.w3.org/2001/XMLSchema#string">
      Smith</sem:object>
 </sem:triple>
 <sem:triple>
  <sem:subject>http://example.org/dir/js</sem:subject>
  <sem:predicate>http://xmlns.com/foaf/0.1/knows</sem:predicate> 
  <sem:object datatype="http://www.w3.org/2001/XMLSchema#string">
      Jane Smith</sem:object>
 </sem:triple>
</sem:triples>

You can also embed triples within XML documents and load them into MarkLogic as-is. These are unmanaged triples, with a element node of sem:triple. You do not need the outer sem:triples element for unmanaged triples, but you do need the subject, predicate, and object elements within the sem:triple element.

Here is an embedded triple, contained in an XML document:

<?xml version="1.0" encoding="UTF-8"?>
<article>
  <info>
    <title>News for April 9, 2013</title>
     <sem:triples xmlns:sem="http://marklogic.com/semantics">
       <sem:triple>
        <sem:subject>http://example.org/article</sem:subject>
        <sem:predicate>http://example.org/mentions</sem:predicate>
        <sem:object>http://example.org/London</sem:object>
       <sem:triple>
     </sem:triples>
...
  </info>
</article>

The loaded triples are automatically indexed with a special-purpose index called a triple index. The triple index allows you to immediately search the RDF data for which you have the required privileges.

Querying Triples

You can write native SPARQL queries in Query Console to retrieve information from RDF triples stored in MarkLogic or in memory. When queried with SPARQL, the question of who lives in England? is answered with John and Jane Smith. This is based on the assertion of facts from the above graph model. This is an example of a simple SPARQL SELECT query:

SELECT ?person ?place
WHERE
{ 
  ?person <http://example.org/livesIn> ?place .
  ?place <http://example.org/isIn> http://xmlns.com/foaf/0.1/name/London. 
}

You can also use XQuery to execute SPARQL queries with sem:sparql. For example:

xquery version "1.0-ml";
import module namespace sem = "http://marklogic.com/semantics" at
  "/MarkLogic/semantics.xqy";

sem:sparql("
PREFIX kennedy:<http://example.org/kennedy> 
SELECT *
WHERE
{ 
?s ?p ?o .
FILTER (regex(?o, 'Joseph', 'i'))
}
")

For more information about using SPARQL and sem:sparql to query triples, see Semantic Queries.

Using XQuery, you can query across triples, documents, and values with cts:triples or cts:triple-range-query.

Here is an example using a cts:triples query:

xquery version "1.0-ml";
import module namespace sem = "http://marklogic.com/semantics" 
  at "/MarkLogic/semantics.xqy";

let $r :=
  cts:triples(sem:iri("http://example.org/people/dir"), 
    sem:iri("http://xmlns.com/foaf/0.1/knows"),
    sem:iri("person1"))

return <result>{$r}</result>

The following is an example of a query that uses cts:triple-range-query:

xquery version "1.0-ml";
import module namespace sem = "http://marklogic.com/semantics" 
  "at /MarkLogic/semantics.xqy";

let $query := cts:triple-range-query(
  sem:iri("http://example.org/people/dir"), 
  sem:iri("http://xmlns.com/foaf/0.1/knows"), ("person2"), "sameTerm")

return cts:search(fn:collection()//sem:triple, $query)

You can create combination queries with cts:query functions such as cts:or-query or cts:and-query.

For example:

xquery version "1.0-ml";
import module namespace sem = "http://marklogic.com/semantics" 
  at "MarkLogic/semantics.xqy";

declare namespace dc = "http://purl.org/dc/elements/1.1/";

  cts:search(collection()//sem:triple, cts:or-query((
    cts:triple-range-query((), sem:curie-expand("foaf:name"), 
      "Lamar Alexander", "="),
    cts:triple-range-query(sem:iri("http://www.rdfabout.com/rdf/usgov
      /congress/people/A000360"), sem:curie-expand("foaf:img"), (),
  "="))))

For more information about cts:triples and the cts:triple-range-query queries, see Semantic Queries.

You can also use the results of a SPARQL query with an XQuery search to create combination queries.

For example:

xquery version "1.0-ml";
import module namespace sem = "http://marklogic.com/semantics"
  at "/MarkLogic/semantics.xqy";
import module namespace semi = "http://marklogic.com/semantics/impl" 
  at "/MarkLogic/semantics/sem-impl.xqy";

declare namespace sr = "http://www.w3.org/2005/sparql-results";

let $results := sem:sparql( "prefix k: <http://example.org/kennedy>
select * { ?s k:latitude ?lat . ?s k:longitude ?lon }" ) 
let $xml := sem:sparql($results)

return
for $sol in $xml/sr:results/sr:result
let $point := cts:point(xs:float($sol/sr:binding[@name eq
'lat']/sr:literal), xs:float($sol/sr:binding[@name eq
'lon']/sr:literal))
return <place name="{$sol/sr:binding[@name eq 's']/*}"
point="{$point}"/>

For more information about combination queries, see Querying Triples with XQuery or JavaScript.

IRIs

IRIs (Internationalized Resource Identifiers) are internationalized versions of URIs (Uniform Resource Identifiers). URIs use a subset of ASCII characters and are limited to this set. IRIs use characters beyond ASCII, making them more useful in an international context. IRIs (and URIs) are unique resource identifiers that enable you to fetch a resource. A URN (Uniform Resource Name) can also be used to uniquely identify a resource.

An IRI may appear similar a URL and may or may not be an actual website. For example:

<http://example.org/addressbook/d> 

IRIs are used instead of URIs, where appropriate, to identify resources. Since SPARQL specifically refers to IRIs, later chapters in this guide reference IRIs and not URIs.

IRIs are required to eliminate ambiguity in facts, particularly if data is received from different data sources. For example, if you are receiving information about books from different sources, one publisher may refer to the name of the book as title, another source may refer to the position of the author as title. Similarly, one domain may refer to the writer of the book as the author and another as creator.

Presenting the information with IRIs (and URNs ), we see a clearer presentation of what the facts mean. The following examples are three sets of N-Triples:

<http://example.org/people/title/sh1999>
<http://www.w3.org/1999/02/22-rdf-syntax-ns#label>
"Lucasian Professor of Mathematics"

<urn:isbn:9780553380163> 
<http://purl.org/dc/elements/1.1/title> 
"A Brief History of Time"

<urn:isbn:9780553380163> 
<http://purl.org/dc/elements/1.1/creator> 
"Stephen Hawking"

Note: Line breaks have been inserted for the purposes of formatting, which make this RDF N-Triple syntax invalid. Each triple would normally be on one line. (Turtle syntax allows for single triples to wrap across multiple lines.)

The IRI is a key component of RDF, however IRIs are usually long and are difficult to maintain. Compact URI Expressions (CURIEs) are supported as a mechanism for abbreviating IRIs. These are specified in the CURIE Syntax Definition:

http://www.w3.org/TR/rdfa-syntax/#s_curies

Prefixes

Prefixes are identified by IRIs and often begin with the name of an organization or company. For example:

PREFIX js: <http://example.org/people/about/js/>

A prefix is a shorthand string used to identify a name. The designated prefix binds a prefix IRI to the specified string. The prefix can then be used instead of writing the full IRI each time it is referenced. When you use prefixes to write RDF, the prefix is followed by a colon. You can choose any prefix for resources that you define. For example, here is a SPARQL declaration:

PREFIX dir: <http://example.org/people/about/>

You can also use standard and agreed upon prefixes that are a part of a specification. This is a SPARQL declaration for rdf:

PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns/>

The prefix depends on the serialization that you use. The Turtle prefix declaration would be:

@prefix dir: <http://example.org/people/about/> .

All PREFIX declarations must end with a forward slash (/) or a hashtag (#). These separate the prefix from the final part of the IRI.