SPARQL and XQuery/JavaScript Together

In this exercise, you'll learn how to use SPARQL and either XQuery or JavaScript together in a few different ways. We'll write queries on the BBC news documents and related triples we loaded in the second exercise. We will provide examples in both XQuery and JavaScript. When referring to MarkLogic-specific functions, we'll include the JavaScript name of the function in parentheses. For example, "sem:sparql (sem.sparql)" refers to the XQuery sem:sparql function and the JavaScript version of that same function is called sem.sparql.

We have provided versions of these queries in the associated Query Console workspace, sparql-xquery.xml.

Using sem:sparql (sem.sparql)

From Query Console, use query type "XQuery" or "JavaScript" against your "tutsem-content" database. When you run in XQuery, wrap the SPARQL with sem:sparql(). The sem:sparql XQuery function is a built-in function so you don't have to import a library to use it.

When you run in JavaScript, wrap the SPARQL with sem.sparql(), and don't forget:

const sem = require('/MarkLogic/semantics.xqy');

For example, the following simple query for people born in Brooklyn can be written in XQuery or JavaScript:

XQuery
JavaScript

sem:sparql('

SELECT * 
WHERE { ?s <http://dbpedia.org/ontology/birthPlace> <http://dbpedia.org/resource/Brooklyn> }

')

const sem = require('/MarkLogic/semantics.xqy');

sem.sparql( 
'SELECT *  \
WHERE { ?s <http://dbpedia.org/ontology/birthPlace> <http://dbpedia.org/resource/Brooklyn> }' 
);

Passing parameters from XQuery or JavaScript into SPARQL

If you recall from our previous exercise, for a specific IRI, we can find all the subjects added by OpenCalais and organize them by type with a SPARQL query like:

PREFIX oc: <http://s.opencalais.com/1/pred/> PREFIX owl: <http://www.w3.org/2002/07/owl#> PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> # @title All subjects for a given News Item. CONSTRUCT { <http://www.bbc.co.uk/news/world-asia-22965046> $type $name . } FROM <http://www.bbc.co.uk/news/graph> WHERE { SELECT DISTINCT $subject $type $name WHERE { $DocInfo owl:sameAs <http://www.bbc.co.uk/news/world-asia-22965046> . $thing oc:docId $DocInfo ; oc:subject $subject . $subject oc:name $name ; rdf:type $type . } ORDER BY $type }

But, let's say we'd like to do this for an arbitrary document. The XQuery sem:sparql or JavaScript sem.sparql function takes a second parameter, which is a map of parameter bindings. We can use it to pass in an IRI like this:

XQuery
JavaScript

let $bindings := map:map()
let $_ := map:put($bindings, "doc", sem:iri( "http://www.bbc.co.uk/news/world-asia-22965046" ) )

return sem:sparql('

PREFIX oc:    <http://s.opencalais.com/1/pred/>
PREFIX owl:   <http://www.w3.org/2002/07/owl#>
PREFIX rdf:   <http://www.w3.org/1999/02/22-rdf-syntax-ns#>

# @title All subjects for a given News Item.

CONSTRUCT {
  $doc $type $name .
}
FROM <http://www.bbc.co.uk/news/graph>
WHERE {
  SELECT DISTINCT $subject $type $name
  WHERE {
    $DocInfo owl:sameAs $doc .
    $thing oc:docId $DocInfo ;
           oc:subject $subject .
    $subject oc:name $name ;
             rdf:type $type .
  } ORDER BY $type
}

',
$bindings)

const sem = require('/MarkLogic/semantics.xqy');

var bindings = {'doc': sem.iri('http://www.bbc.co.uk/news/world-asia-22965046')};

sem.sparql('\n\
PREFIX oc:    <http://s.opencalais.com/1/pred/>\n\
PREFIX owl:   <http://www.w3.org/2002/07/owl#>\n\
PREFIX rdf:   <http://www.w3.org/1999/02/22-rdf-syntax-ns#>\n\
\n\
# @title All subjects for a given News Item.\n\
\n\
CONSTRUCT {\n\
  $doc $type $name .\n\
}\n\
FROM <http://www.bbc.co.uk/news/graph>\n\
WHERE {\n\
  SELECT DISTINCT $subject $type $name\n\
  WHERE {\n\
    $DocInfo owl:sameAs $doc .\n\
    $thing oc:docId $DocInfo ;\n\
           oc:subject $subject .\n\
    $subject oc:name $name ;\n\
             rdf:type $type .\n\
  } ORDER BY $type\n\
}', 
bindings);

Neato!

Now, if you know how to use MarkLogic XQuery or JavaScript search APIs, you should be able to find all news items with "Elton John" in their title and show their OpenCalais subjects. Try this on your own (the answer is in the provided sparql-xquery.xml workspace).

Restricting a SPARQL with a cts:query (cts.query)

The call, sem:sparql in XQuery or sem.sparql in JavaScript, actually takes several arguments beyond the bindings we used above. In particular, you can use the fourth argument to constrain the query.

Let's say you're interested in cities. First you can find all the cities mentioned in the news like this:

SELECT DISTINCT ?cityName WHERE { ?resource <http://s.opencalais.com/1/type/em/e/City> ?cityName }

But now, say you'd like to restrict that to city names mentioned in certain articles. Here, let's find all the city names referenced in articles that have the phrase "dark magic". We can constrain the SPARQL query as:

XQuery
JavaScript

xquery version "1.0-ml";

(: show cities mentioned in items that contain the phrase "dark magic" :)

sem:sparql('
SELECT ?cityName ?headline
WHERE {
  ?resource ?pred <http://s.opencalais.com/1/type/em/e/City> ;
            <http://s.opencalais.com/1/pred/name> ?cityName .
  ?busSubj ?itemPred <http://iptc.org/std/rNews/2011-10-07#NewsItem> ;
           <http://iptc.org/std/rNews/2011-10-07#headline> ?headline .
}
', (), (), cts:word-query("dark magic"))

const sem = require('/MarkLogic/semantics.xqy');

// show cities mentioned in items that contain the phrase "dark magic" 

sem.sparql('\n\
SELECT ?cityName ?headline\n\
WHERE {\n\
  ?resource ?pred <http://s.opencalais.com/1/type/em/e/City> ;\n\
            <http://s.opencalais.com/1/pred/name> ?cityName .\n\
  ?busSubj ?itemPred <http://iptc.org/std/rNews/2011-10-07#NewsItem> ;\n\
           <http://iptc.org/std/rNews/2011-10-07#headline> ?headline .\n\
}', [], [], cts.wordQuery("dark magic"));

CONSTRUCT new triples and insert them with XQuery or JavaScript

OK, now let's go the other way, taking something from SPARQL and passing it into either XQuery or JavaScript.

Let's use SPARQL CONSTRUCT to construct triples and then XQuery's xdmp:node-insert-child() or JavaScript's xdmp.nodeInsertChild() to insert them into a document. (Yes, you can embed triples directly in documents ourselves if you want).

XQuery
JavaScript

xquery version "1.0-ml";
declare namespace html = "http://www.w3.org/1999/xhtml";

(: for some document URI, get its OpenCalais headings; format them into triples; insert those triples into the document :)

let $docURI := "/news/content/business-23095938.xml"
let $thisDoc := fn:doc( $docURI )

let $bindings := map:map()
let $_ := map:put($bindings, "doc", sem:iri( $thisDoc/html:html/html:head/@resource ) )

let $triples := sem:sparql('

PREFIX oc:    <http://s.opencalais.com/1/pred/>
PREFIX owl:   <http://www.w3.org/2002/07/owl#>
PREFIX rdf:   <http://www.w3.org/1999/02/22-rdf-syntax-ns#>

CONSTRUCT {
  $doc $type $name .
}
FROM <http://www.bbc.co.uk/news/graph>
WHERE {
  SELECT DISTINCT $subject $type $name
  WHERE {
    $DocInfo owl:sameAs $doc .
    $thing oc:docId $DocInfo ;
           oc:subject $subject .
    $subject oc:name $name ;
             rdf:type $type .
  } ORDER BY $type
}
',

$bindings)

return 
  xdmp:node-insert-child(
    fn:doc( $docURI )/html:html/html:head ,
    
    )

declareUpdate();

const sem = require('/MarkLogic/semantics.xqy');

// for some document URI, get its OpenCalais headings; format them into triples; insert those triples into the document

const docURI = '/news/content/business-23095938.xml';
const iri = fn.head(cts.doc( docURI ).xpath('/html:html/html:head/@resource', {html:'http://www.w3.org/1999/xhtml'}));
var bindings = {doc: sem.iri( iri )};

var triples = sem.sparql('\n\
\n\
PREFIX oc:    <http://s.opencalais.com/1/pred/>\n\
PREFIX owl:   <http://www.w3.org/2002/07/owl#>\n\
PREFIX rdf:   <http://www.w3.org/1999/02/22-rdf-syntax-ns#>\n\
\n\
CONSTRUCT {\n\
  $doc $type $name .\n\
}\n\
FROM <http://www.bbc.co.uk/news/graph>\n\
WHERE {\n\
  SELECT DISTINCT $subject $type $name\n\
  WHERE {\n\
    $DocInfo owl:sameAs $doc .\n\
    $thing oc:docId $DocInfo ;\n\
           oc:subject $subject .\n\
    $subject oc:name $name ;\n\
             rdf:type $type .\n\
  } ORDER BY $type\n\
}', bindings);

// serialize the created triples to MarkLogic sem:triples format
var serializedTriples = sem.rdfSerialize(triples, 'triplexml');

// make a new XML node called 'enrichment' and insert the new triples as children of the new node
const builder = new NodeBuilder();
builder.startElement('enrichment');
for (var triple of serializedTriples.xpath('//sem:triple', {sem:'http://marklogic.com/semantics'}))
  builder.addNode(triple);
builder.endElement();

// add the new 'enrichment' node containing the new triples to the original document
xdmp.nodeInsertChild(
    cts.doc( docURI ).xpath('/html:html/html:head', {html:'http://www.w3.org/1999/xhtml'}),
    builder.toNode());

Yes, it's that easy to take the output of a SPARQL query and use it in XQuery or JavaScript.

Serializing SPARQL results as XML, JSON, or triples

What formats does sem:sparql() or sem.sparql() return? You can try each of the different kinds of SPARQL queries (SELECT, CONSTRUCT, ASK, DESCRIBE) and wrap them in xdmp:describe() or xdmp.describe() to see the format of the result. There are queries in the associated workspace for this, but in case you're too impatient to click over, here's what you'll get:

Query	Return
SELECT	sequence of JSON objects
CONSTRUCT	sequence of sem:triple()
ASK	boolean
DESCRIBE	sequence of sem:triple()

There are a couple other useful functions for serializing RDF and SPARQL query results that you can use:

sem:rdf-serialize() (XQuery), sem.rdfSerialize() (JavaScript) – serialize sem:triple (XQuery) or sem.triple (JavaScript) to RDF (turtle, ntriple, and so on)
sem:query-results-serialize() (XQuery) or sem.queryResultsSerialize() (JavaScript) – serialize ANY SPARQL result (from sem:sparql or sem.sparql) as XML or JSON

As an exercise, you can use these to format the results of each kind of SPARQL query as RDF (where applicable), XML, or JSON.

References

Query Console Workspace ts-sparql-xquery.xml.

Introducing SPARQL

Using the Triple Index

Contents