{"id":52,"date":"2015-06-22T15:57:40","date_gmt":"2015-06-22T15:57:40","guid":{"rendered":"http:\/\/cors1601.unl.edu\/cdrhdev\/?p=52"},"modified":"2025-10-06T14:28:27","modified_gmt":"2025-10-06T19:28:27","slug":"rdf-sparql-1","status":"publish","type":"post","link":"https:\/\/cdrhdev.unl.edu\/log\/2015\/rdf-sparql-1\/","title":{"rendered":"Figuring Out RDF and SPARQL: Part I Triples"},"content":{"rendered":"

[Originally posted by Jessica Dussault, June 22, 2015 on Github Pages]<\/p>\n

Linked Data. The Semantic Web. A lot of those terms have been rattling around in my brain for years, picked up from various digital humanities events and lectures. We started on a new project that hopes to use linked data to analyze relationships between hundreds of individuals. Theoretically, I understood what this meant, but practically I had absolutely no idea how to start implementing it.<\/p>\n

I felt lost for a few days as I wallowed through lots of high level articles that all gave me the same introduction or as I got stuck in the details of software I never should have looked at to begin with. I even got briefly lost down a wikipedia rabbit hole of grammar when I looked up \u201cpredicate,\u201d since that word comes up a lot in linked data. I felt like I was missing a page in the owner\u2019s manual. Where was the \u201cQuick Setup\u201d chapter?<\/p>\n

\n
\"Sentence
The programmer has NOT been enjoying reading about predicates, thanks<\/figcaption><\/figure>\n<\/div>\n
What follows is certainly not the best introduction to linked data, but it is the kind of information that I was looking for as a step between beginning overviews and \u201cso now that you\u2019re all set up\u2026\u201d articles. The next few blog posts are, essentially \u201chow to actually set up some RDF.\u201d But first, the obligatory post on what it is.<\/div>\n

Okay, so what are RDFs and OWLs?<\/h2>\n

Great question! Think of a relational database. It can do a lot of things, but if you put a bunch of people into it and then asked \u201cfind everybody related to person A (and HOW they are related), then find everybody that is related to all of THOSE people, too (as well as the nature of their relationship)\u201d it would get\u2026.complicated. This is where RDF shines.<\/p>\n

RDFs (Resource Description Frameworks) use a model based on \u201ctriples.\u201d Triples follow an object\u00a0\u00bb predicate\u00a0\u00bb subject format.<\/p>\n

\n
Sisko >> is on the show >> DS9\nSisko >> is rank >> captain\nPicard >> is rank >> captain\nPicard >> is on the show >> TNG\nDax >> is rank >> lt commander\nDax >> is on the show >> DS9\n<\/code><\/pre>\n<\/div>\n
\n
\"Scene
It’s okay to use Star Trek examples because RDF exists in Star Trek, too, as a Reality Distortion Field.<\/figcaption><\/figure>\n
<\/p>\n<\/div>\n
<\/div>\n
From the above information one could write queries like \u201cfind all the captains,\u201d \u201clist the characters that appear on DS9,\u201d or \u201cfind all of the unique shows that a crew member appears on.\u201d But those questions aren\u2019t terribly difficult to do in a more familiar relational database model. Let\u2019s make it a little more interesting.<\/div>\n
<\/div>\n
\n
Dax >> served with >> Worf\nDax >> is married to >> Worf\nWorf >> served with >> Dax\nWorf >> is married to >> Dax\nPicard >> served with >> Worf\nWorf >> served with >> Picard\nPicard >> has met >> Sisko\nSisko >> has met >> Picard\nDax >> served with >> Sisko\nSisko >> served with >> Dax\n(etc)\n<\/code><\/pre>\n<\/div>\n
Now you could ask a question like \u201cFind all the people that Picard knows and then find all the people that THEY know (excluding the original person).\u201d You would get something like the following from that query:<\/p>\n
\n
Picard | served with | Worf  | served with   | Dax\nPicard | served with | Worf  | is married to | Dax\nPicard | served with | Worf  | served with   | Sisko\nPicard | has met     | Sisko | served with   | Worf \nPicard | has met     | Sisko | served with   | Dax \n<\/code><\/pre>\n<\/div>\n
\n
\"Picard's
A basic visualization of our findings.<\/figcaption><\/figure>\n<\/div>\n
<\/div>\n
Though, to my knowledge, Picard has never met Dax, it would appear that they run in the same circles. This is a fairly small dataset, but if we had more crew members described in the triples, we could start constructing webs of relationships.<\/div>\n
<\/div>\n
\n
\"Kirk,
A larger sampling of data would reveal that Sisko has met Kirk and Uhura. I bet you didn\u2019t remember that<\/figcaption><\/figure>\n<\/div>\n
<\/div>\n
You can write very specific queries (\u201chow is Worf related to Dax?\u201d) or you can write very broad queries to scoop in a lot of results (\u201cgive me a list of every one-to-one relationship\u201d) or something in between (\u201ctell me what you know about Sisko\u201d).<\/div>\n
Of course, writing the triples doesn\u2019t look nearly so nice as my arrow delineated examples above. Here is an example of what one entry from the Oh Say Can You See<\/a> data looks like at this phase of the project.<\/p>\n
An excerpt from an RDF file<\/p>\n
<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<rdf:RDF xmlns:rdf=\"http:\/\/www.w3.org\/1999\/02\/22-rdf-syntax-ns#\" xmlns:oscys=\"http:\/\/server.unl.edu\/rdf\/oscys.owl#\">\n  <rdf:Description rdf:about=\"http:\/\/server.unl.edu\/rdf\/oscys_test#per.000056\">\n    <rdf:type>person<\/rdf:type>\n    <oscys:fullName>Queen, Louisa<\/oscys:fullName>\n    <oscys:sex>female<\/oscys:sex>\n    <oscys:childOf rdf:resource=\"http:\/\/server.unl.edu\/rdf\/oscys_test#per.000057\"\/>\n    <oscys:enslavedBy rdf:resource=\"http:\/\/server.unl.edu\/rdf\/oscys_test#per.000058\"\/>\n    <oscys:petitionerAgainst rdf:resource=\"http:\/\/server.unl.edu\/rdf\/oscys_test#per.000058\"\/>\n    <oscys:clientOf rdf:resource=\"http:\/\/server.unl.edu\/rdf\/oscys_test#per.000001\"\/>\n    <oscys:judgedBy rdf:resource=\"http:\/\/server.unl.edu\/rdf\/oscys_test#per.000004\"\/>\n    <oscys:judgedBy rdf:resource=\"http:\/\/server.unl.edu\/rdf\/oscys_test#per.000063\"\/>\n  <\/rdf:Description>\n<\/rdf:RDF><\/pre>\n
Well, okay, that looks way more complicated than the examples above. What it is really saying is the following:<\/p>\n
\n
person 000056 >> is a >> person\nperson 000056 >> is named >> Queen, Louisa\nperson 000056 >> sex is >> female\nperson 000056 >> is a child of >> person 000057\n(etc)\n<\/code><\/pre>\n<\/div>\n
It looks a lot more complicated because it is using a mixture of literals and resources. Literals are just straight up text and numbers. An example above is the person\u2019s fullName: \u201cQueen, Louisa.\u201d Resources are the URIs that point at other entries in the RDF document (or even in other RDF documents). If you wanted to reference this particularly person, you would use the URI with #per.000056 on the end. You could have defined the references to other people are literals like \u201cper.000004\u201d but then the magic of linked data would be lost. Its power comes from knowing that the childOf relationship is one specific person and having access to the relationships and descriptions of that person as well. So perhaps the above translation would be more accurate if we said:<\/p>\n
\n
http:\/\/path#person000056 >> is a child of >> http:\/\/path#person000057\n<\/code><\/pre>\n<\/div>\n
But wait, there\u2019s just one more detail in the RDF that we can\u2019t overlook. There is a namespace \u201coscys\u201d before most of the lines describing the person. This namespace is defining the predicates. That is to say, one can write down \u201cchildOf\u201d wherever they like but that doesn\u2019t mean anything to a computer. In fact, it might not mean a ton to hu-mans like us out of context, either. All of those predicates can be described in what I have been thinking of as a schema file, but which the internet likes to call a \u201contological\u201d file. This is where OWLs come in.<\/p>\n
\n
\"An
Fun fact, OWL stands for Web Ontology Language. That doesn\u2019t actually spell \u2018OWL\u2019 but I assume they wanted to use it because there aren\u2019t many cute images of WOLs.<\/figcaption><\/figure>\n
<\/p>\n<\/div>\n
<\/div>\n
An excerpt from the Oh Say Can You See OWL file:<\/div>\n
\n
<owl:ObjectProperty rdf:about=\"#parentOf\">\n  <rdfs:domain rdf:resource=\"#Person\"\/>\n  <rdfs:range rdf:resource=\"#Person\"\/>\n  <owl:Inverseof rdf:resource=\"childOf\"\/>\n  <rdfs:subPropertyOf rdf:resource=\"#familyOf\"\/>\n<\/owl:ObjectProperty><\/pre>\n
To connect them up, just make sure that you\u2019re referencing the OWL file at the top of your RDF file. In the example RDF file, you\u2019ll see that it is assigned to the namespace \u201coscys.\u201d<\/p>\n<\/div>\n
Let\u2019s break down the OWL example:<\/p>\n
\n
#parentOf >> domain >> #Person\n#parentOf >> range >> #Person\n#parentOf >> inverseOf >> childOf\n#parentOf >> subPropertyOf >> #familyOf\n<\/code><\/pre>\n<\/div>\n
That means that now we know that anybody joined up as the oscys:childOf predicate will return an object that should be the oscys:parentOf the original person. We could also do a search for all the predicates that are #familyOf and use those results to find all family relationships for a single person. Pretty cool stuff, right?<\/p>\n
Thus endeth the crash course in what kind of things RDF does. Next up, how to actually start running the queries!<\/p>\n