{"id":1120,"date":"2019-10-28T17:41:49","date_gmt":"2019-10-28T17:41:49","guid":{"rendered":"http:\/\/www.macs.hw.ac.uk\/SWeL\/?p=1120"},"modified":"2021-10-27T16:26:13","modified_gmt":"2021-10-27T15:26:13","slug":"sparql-for-beginners","status":"publish","type":"post","link":"https:\/\/www.macs.hw.ac.uk\/SWeL\/2019\/10\/28\/sparql-for-beginners\/","title":{"rendered":"SPARQL For Beginners"},"content":{"rendered":"\n

\n SPARQL<\/a> (S<\/b>parql P<\/b>rotocol A<\/b>nd R<\/b>DF Q<\/b>uery L<\/b>anguage) is the W3C standard<\/a>. The protocol part is usally only an issue for people writing programs that pass SPARQL queries back and forth between different machines. For most people SPARQL greatest value is as a query language for RDF<\/a> – another W3C standard. RDF describes data using a collection of three-part of one statement such as emp3 has a title of Vice President<\/em>.
\n \n <\/p>\n

\n We call each statement a triple and one triple consist of three parts these are Subject<\/em>, Predicate<\/em> and Object<\/em>.\n \n <\/p>\n

\n We can also say the Subject as an Entity Identifier, Predicate as an Attribute Name and Object as an Attribute Value.\n \n <\/p>\n

\n The subject and predicate are actually represented using URIs to make it absolutely clear what we are talking about. URIs (Uniform Resource Identifier) kind of URLs and often look like them but they are not locators or addresses they are just identifiers. In our example, emp3 is the person who works in a specific company so we can represent this using URI like http:\/\/www.snee.com\/hr\/emp3 and title is also URI from the published ontology (In our case VCard business card ontology<\/a>).\n \n <\/p>\n

\n The object or third part of a triple can also be a URI if you like this way that same resource can be the object of some triples\n \n and subject of the others which lets you connect up triples into networks of data called Graphs.\n \n <\/p>\n

\n To make URIs simpler to write RDF popular Turtle<\/a> syntax often shortens the URIs by having the abbreviated prefix stand-in for everything in the URI before the last part.\n \n <\/p>\n

\n Any data can be represented as a collection of triples for example we can usually represent each entry of a table by using the Row Identifier<\/em> is the Subject<\/b>, Column Name<\/em> is the Predicate<\/b> and Value<\/em> is the Object<\/b>.\n \n <\/p>\n

\n

Convert Relational Database Table to RDF Statements<\/h4>\n
\n We can convert above table in RDF triple statements. The following RDF statements are in Turtle format of above table.\n 
 \n                                \n    @prefix vcard: <http:\/\/www.w3.org\/2006\/vcard\/ns#> .\n    @prefix sn: <http:\/\/www.snee.com\/hr\/> .\n    <\/span>\n\n    sn:emp1   vcard:given-name<\/span>        \"Heidi\" .\n    sn:emp1   vcard:family-name<\/span>       \"Peter\" .\n    sn:emp1   vcard:title<\/span>             \"CEO\" .\n    sn:emp1   sn:hireDate<\/span>             \"2016-10-21\" .\n    sn:emp1   sn:completedOrientation<\/span> \"2016-10-30\" .\n\n    sn:emp2   vcard:given-name<\/span>         \"John\" .\n    sn:emp2   vcard:family-name<\/span>        \"Peter\" .\n    sn:emp2   sn:hireDate<\/span>              \"2016-10-28\" .\n    sn:emp2   vcard:title<\/span>              \"Engineer\" .\n    sn:emp2   sn:completedOrientation<\/span>  \"2015-01-30\" .\n\n    sn:emp3   vcard:given-name<\/span>          \"Imran\" .\n    sn:emp3   vcard:family-name<\/span>         \"Asif\" .\n    sn:emp3   sn:hireDate<\/span>               \"2014-12-03\" .\n    sn:emp3   vcard:title<\/span>               \"Vice President\" .\n\n    sn:emp4   vcard:given-name<\/span>          \"Duke\" .\n    sn:emp4   vcard:family-name<\/span>         \"Walliam\" .\n    sn:emp4   vcard:title<\/span>               \"Sales\" .\n    sn:emp4   sn:hireDate<\/span>               \"2015-11-10\" .\n<\/code><\/pre>\n                            <\/p>\n                            
\n                                Let\u2019s say that the employee in the above table<\/a>, John Peter completed his employee orientation course twice and if we want to store both of his completed course orientation values in the RDF then there is not a problem with the RDF. But if we want to stored John\u2019s second completed orientation value in a relational database table then it would have been a lot more difficult.\n                                
 \n    sn:emp2   vcard:given-name          \"John\" .\n    sn:emp2   vcard:family-name         \"Peter\" .\n    sn:emp2   sn:hireDate               \"2016-10-28\" .\n    sn:emp2   vcard:title               \"Engineer\" .\n    sn:emp2   sn:completedOrientation   \"2015-01-30\" .\n    sn:emp2   sn:completedOrientation   \"2015-03-15\" .<\/span>\n<\/code><\/pre>\n                            <\/p>\n                            
SPARQL Example Queries<\/h4>\n                            
\n                            
WHERE Clause<\/h5>\n                            
\n                                let’s look at a simple SPARQL query that retrieve some of the data from the above RDF Triples<\/a>. 
Query 1: We want a list of all employees whose last name is Peter.<\/b>\n                                
\n                                \n    PREFIX vcard: <http:\/\/www.w3.org\/2006\/vcard\/ns#>\n    \n    SELECT ?person\n    WHERE\n    {\n      ?person vcard:family-name \"Peter\" .\n    }<\/code><\/pre>\n                            <\/p>\n                            
\n                                We can define the prefixes in the start of SPARQL query due to the Turtle RDF syntax, that\u2019s why you don\u2019t have to write absolute URIs in your queries. For most SPARQL queries it\u2019s best to look at the Where<\/em> clause first because that describe which triples we want to pull from the dataset that we are querying. The Where<\/em> clause does this with one or more triple patterns which are likely triples with variables as wildcards substituted into one, two or all three of each triples parts.\n                            <\/p>\n                            
\n                                In the Query 1<\/a>, one triple pattern will match against triples whose predicate is the family name property from the vCard vocabulary, whose object is string Peter<\/b> and whose subject is anything at all. Because this triple pattern has a variable that I named person<\/b>.\n                            <\/p>\n                            
SELECT Clause<\/h5>\n                            
\n                                The Select clause indicates which variables values we want listed after the query executes. The Query 1<\/a> only has one variable so that\u2019s the one we want to see.\n                            <\/p>\n                            
\n                                When the query executes, it finds two triples that match the specified pattern from the RDF triples set and assigned these two triples to the person variable which are the subjects e.g., emp1 and emp2. The following triples show the two matches of the above query with green colour.\n                                
 \n    @prefix vcard: <http:\/\/www.w3.org\/2006\/vcard\/ns#> .\n    @prefix sn: <http:\/\/www.snee.com\/hr\/> .\n\n    sn:emp1   vcard:given-name        \"Heidi\" .\n    sn:emp1   vcard:family-name       \"Peter\" .<\/span>\n    sn:emp1   vcard:title             \"CEO\" .\n    sn:emp1   sn:hireDate             \"2016-10-21\" .\n    sn:emp1   sn:completedOrientation \"2016-10-30\" .\n\n    sn:emp2   vcard:given-name         \"John\" .\n    sn:emp2   vcard:family-name        \"Peter\" .<\/span>\n    sn:emp2   sn:hireDate              \"2016-10-28\" .\n    sn:emp2   vcard:title              \"Engineer\" .\n    sn:emp2   sn:completedOrientation  \"2015-01-30\" .\n    sn:emp2   sn:completedOrientation  \"2015-03-15\" .\n\n    sn:emp3   vcard:given-name          \"Imran\" .\n    sn:emp3   vcard:family-name         \"Asif\" .\n    sn:emp3   sn:hireDate               \"2014-12-03\" .\n    sn:emp3   vcard:title               \"Vice President\" .\n\n    sn:emp4   vcard:given-name          \"Duke\" .\n    sn:emp4   vcard:family-name         \"Walliam\" .\n    sn:emp4   vcard:title               \"Sales\" .\n    sn:emp4   sn:hireDate               \"2015-11-10\" .\n<\/code><\/pre>\n                            <\/p>\n                            
\n                                Let’s executes the Query 1<\/a> and find out who are these Peters. we get the following table as a result.
\n                                \n                            <\/p>\n                            
\n                                From the above results, we can see that emp1 and emp2 are just identifiers. This doesn\u2019t give us meaningful result. 
Query 2: Now let’s add a second triple pattern in the WHERE<\/em> clause that matches on the given name of the employee, who matches the first triple pattern and stores that value in a new givenName<\/b> variable<\/b>.\n                                
\n                                \n    PREFIX vcard: <http:\/\/www.w3.org\/2006\/vcard\/ns#> \n\n    SELECT ?person ?givenName\n    WHERE \n    { \n       ?person vcard:family-name \"Peter\" . \n       ?person vcard:given-name ?givenName .\n    }<\/code><\/pre>\n                            <\/p>\n                            
\n                                The explanation of the Query 2<\/a> is that we need to adjust the SELECT<\/em> Clause with the new variable givenName because now we want this in the result. The SPARQL query processor finds each triple that matches the first triple pattern and store the value in the person variable. When it looks for the second triple pattern in the WHERE<\/em> clause, who have a triple that matches the first triple pattern. In easy words, SPARQL processor get all triples of family-name Peter along with given-name. So when we run the Query 2<\/a> we see given name values in the result.\n                                \n                            <\/p>\n                            
\n                                Query 3: Let’s retrieve the given name, family name and hire date of all the employees.<\/b>
 We can do this with a WHERE<\/em> Clause that has three triple patterns one for each piece of information that we want to retrieve.\n                                
\n    PREFIX vcard: <http:\/\/www.w3.org\/2006\/vcard\/ns#>\n    PREFIX sn: <http:\/\/www.snee.com\/hr\/>\n\n    SELECT ?givenName ?familyName ?hireDate\n    WHERE\n    {\n        ?person vcard:given-name ?givenName .\n        ?person vcard:family-name ?familyName .\n        ?person sn:hireDate ?hireDate .\n    }\n<\/code><\/pre>\n                            <\/p>\n                            
\n                                When we run the query 3<\/a>, we get the following results.\n                                \n                            <\/p>\n                            
FILTER Keyword<\/h5>\n                            
\n                                If we want to narrow down the results based on some condition, we can use a FILTER<\/em> pattern. 
 Query 4: Let\u2019s say we want a list of employees who are hired before November 1st<\/sup> so the FILTER<\/em> pattern specifies that we only want HD values that are less than November 1st<\/sup> 2015<\/b>.\n                                
\n    PREFIX vcard: <http:\/\/www.w3.org\/2006\/vcard\/ns#>\n    PREFIX sn: <http:\/\/www.snee.com\/hr\/>\n\n    SELECT ?givenName ?familyName ?hireDate\n    WHERE\n    {\n        ?person vcard:given-name ?givenName .\n        ?person vcard:family-name ?familyName .\n        ?person sn:hireDate ?hireDate .\n        FILTER(?hireDate < "2015-11-01")\n    }<\/code><\/pre>\n                            <\/p>\n                            
\n                                When we run the query 4<\/a>, we get the following results in the ISO 8601 date format.\n                                \n                            <\/p>\n                            
\n                                Query 5: Let\u2019s remove the FILTER<\/em> condition and list the employees and their completed orientation values instead of their hire date values.<\/b>\n                                
\n    PREFIX vcard: <http:\/\/www.w3.org\/2006\/vcard\/ns#>\n    PREFIX sn: <http:\/\/www.snee.com\/hr\/>\n\n    SELECT ?givenName ?familyName ?oDate\n    WHERE\n    {\n        ?person vcard:given-name ?givenName .\n        ?person vcard:family-name ?familyName .\n        ?person sn:completedOrientation  ?oDate .\n    }<\/code><\/pre>\n                            <\/p>\n                            
\n                                When we run the query 5<\/a>, we get the following results.\n                                \n                            <\/p>\n                            
\n                                We see only Heidi and John\u2019s orientation dates but the other employees don\u2019t appear at all in the results why not? Let\u2019s look more closely at the query triple patterns. The query first looks for a triple with a given name value and then a triple with the same subject as the subject that it found to match the first triple pattern but with a family name value and then another triple with the same subject and a completed orientation value. John and Heidi each have triples that match all the query triple patterns but Imran and Duke cannot match all three triple patterns. You have noted that John actually had two triples that matched the third pattern of the query, so the query had two rows of results for him, one for each completed orientation value.\n                            <\/p>\n                            
OPTIONAL Keyword<\/h5>\n                            
\n                                Query 6: Let\u2019s take another example, list of all employees and if they have any their completed orientation values.<\/b>
 We can tell query processor that matching on the third triple pattern is OPTIONAL<\/em>.\n                                
\n    PREFIX vcard: <http:\/\/www.w3.org\/2006\/vcard\/ns#>\n    PREFIX sn: <http:\/\/www.snee.com\/hr\/>\n\n    SELECT ?givenName ?familyName ?oDate\n    WHERE\n    {\n        ?person vcard:given-name ?givenName .\n        ?person vcard:family-name ?familyName .\n        OPTIONAL { ?person sn:completedOrientation  ?oDate . }\n    }<\/code><\/pre>\n                            <\/p>\n                            
\n                                This query asks for everyone with a given name and a family name and if they have a completed orientation value it will show the following result.\n                                \n                            <\/p>\n                            
NOT EXISTS Keyword<\/h5>\n                            
\n                                Query 7: Next let\u2019s say that Heidi is scheduling a new orientation meeting and wants to know who to invite, in other words she wants to list all employees who do not have a completed orientation value.<\/b>
 Her query asks for everyone\u2019s given and family names but only if for any employee who matches those first two triple patterns no triple exists that lists a completed orientation value for that employee. We do this with the keywords NOT EXISTS<\/em>.\n                                
\n    PREFIX vcard: <http:\/\/www.w3.org\/2006\/vcard\/ns#>\n    PREFIX sn: <http:\/\/www.snee.com\/hr\/>\n\n    SELECT ?givenName ?familyName\n    WHERE\n    {\n        ?person vcard:given-name ?givenName .\n        ?person vcard:family-name ?familyName .\n        NOT EXISTS { ?person sn:completedOrientation  ?oDate . }\n    }<\/code><\/pre>\n                            <\/p>\n                            
\n                                When we run the query 7<\/a>, we get the following results.\n                                \n                            <\/p>\n                            
BIND Keyword<\/h5>\n                            
\n                                So far, the only way we have seen to store a value in a variable is to include that variable in a triple pattern for the query processor to match against some part of triple. We can use the bind keyword to store whatever we like in a variable.\n                                
\n    PREFIX vcard: <http:\/\/www.w3.org\/2006\/vcard\/ns#>\n    PREFIX sn: <http:\/\/www.snee.com\/hr\/>\n\n    SELECT ?givenName ?familyName ?someVariable\n    WHERE {\n        ?person vcard:given-name ?givenName .\n        ?person vcard:family-name ?familyName .\n        BIND(\"some value\" AS ?someVariable)\n    }<\/code><\/pre>\n                            <\/p>\n                            
\n                                When we run the above query, we get the following results.\n                                \n                            <\/p>\n                            
\n                                This can be especially useful when the BIND expression uses values from other variables and calls some of SPARQL broad range of available functions to create a new value. In the following query the bind statement uses SPARQL\u2019s concat function to concatenate the given name value stored by the first triple pattern a space and the family name value stored by the second triple pattern. It stores the result of this concatenation in a new variable called fullName<\/b>.\n                                
\n    PREFIX vcard: <http:\/\/www.w3.org\/2006\/vcard\/ns#>\n    PREFIX sn: <http:\/\/www.snee.com\/hr\/>\n\n    SELECT ?givenName ?familyName ?fullName\n    WHERE {\n        ?person vcard:given-name ?givenName .\n        ?person vcard:family-name ?familyName .\n        BIND(concat(?givenName,\" \",?familyName) AS ?fullName)\n    }<\/code><\/pre>\n                            <\/p>\n                            
\n                                When we run the above query, we get the following results with new full name value for each employee.\n                                \n                            <\/p>\n                            
CONSTRUCT Clause<\/h5>\n                            
\n                                All the queries we have seen so far have been SELECT<\/em> queries which are like SQL SELECT<\/em> statements. A Sparql construct query uses the same kind of WHERE<\/em> clauses that a SELECT<\/em> query can use but it can use the values stored in the variables to create the new triples.\n                                
\n    PREFIX vcard: <http:\/\/www.w3.org\/2006\/vcard\/ns#>\n    PREFIX sn: <http:\/\/www.snee.com\/hr\/>\n\n    CONSTRUCT {?person vcard:fn ?fullName\n    WHERE {\n        ?person vcard:given-name ?givenName .\n        ?person vcard:family-name ?familyName .\n        BIND(concat(?givenName,\" \",?familyName) AS ?fullName)\n    }<\/code><\/pre>\n                            <\/p>\n                            
\n                                When we run the above query, we get the following new triples.\n                                \n                            <\/p>\n                            
\n                                Note that how the triple pattern showing the triple to construct is inside of curly braces. These curly braces can enclose multiple triple patterns which is a common practice when for example a construct query takes data conforming to one modal and creates triples conforming to another. The construction queries are great for data integration projects.\n                                
\n    PREFIX vcard: <http:\/\/www.w3.org\/2006\/vcard\/ns#>\n    PREFIX sn: <http:\/\/www.snee.com\/hr\/>\n    PREFIX foaf: <http:\/\/xmlns.com\/foaf\/0.1\/>\n    PREFIX rdf: <http:\/\/www.w3.org\/1999\/02\/22-rdf-syntax-ns#>\n\n    CONSTRUCT {\n        ?person rdf:type foaf:Person .\n        ?person foaf:givenName ?givenName .\n        ?person foaf:familyName ?familyName .\n        ?person foaf:name ?fullName .\n    }\n    WHERE {\n        ?person vcard:given-name ?givenName .\n        ?person vcard:family-name ?familyName .\n        BIND(concat(?givenName,\" \",?familyName) AS ?fullName)\n    }<\/code><\/pre>\n                            <\/p>\n                            
\n                                When we run the above query, we get the following new triples.\n                                
\n            @prefix vcard: <http:\/\/www.w3.org\/2006\/vcard\/ns#> .\n            @prefix sn: <http:\/\/www.snee.com\/hr\/> .\n            @prefix foaf: <http:\/\/xmlns.com\/foaf\/0.1\/>\n            @prefix rdf: <http:\/\/www.w3.org\/1999\/02\/22-rdf-syntax-ns#>\n\n            sn:emp1   rdf:type          foaf:Person .\n            sn:emp1   foaf:familyName   \"Peter\" .\n            sn:emp1   foaf:givenName    \"Heidi\"\n            sn:emp1   foaf:name\t\t\"Heidi Peter\"\n\n            sn:emp2   rdf:type          foaf:Person .\n            sn:emp2   foaf:familyName   \"Peter\" .\n            sn:emp2   foaf:givenName    \"John\"\n            sn:emp2   foaf:name\t\t\"John Peter\"\n\n\n            sn:emp2   rdf:type          foaf:Person .\n            sn:emp2   foaf:familyName   \"Asif\" .\n            sn:emp2   foaf:givenName    \"Imran\"\n            sn:emp2   foaf:name\t\t\"Imran Asif\"\n\n            sn:emp2   rdf:type          foaf:Person .\n            sn:emp2   foaf:familyName   \"Walliam\" .\n            sn:emp2   foaf:givenName    \"Duke\"\n            sn:emp2   foaf:name\t\t\"Duke Walliam\"<\/code><\/pre>\n                            <\/p>\n                            
\n                                
SPARQL Do More:<\/h4>\n                                Sparql can do a lot more than what we have seen here. You can\n                                
\n                                This information can give us triples for every fact on the table. Some of the property names here from the vCard vocabulary<\/a>. For those properties that are not available in vCard vocabulary<\/a>, I made up my own property names using my own domain name. RDF makes it easy to mix and mash standard vocabularies and customizations.\n                            <\/p>\n