This lesson is all about basic jargon in RDF graphs, including nodes and edges.

Recognising the 'triple' as the fundamental building block of RDF graphs is key. This lesson illustrates what triples are and their constituent parts.

In RDF, there are three types of nodes - IRI nodes, literals and blank nodes. Being able to recognise and work with IRI nodes and literals is key in the beginner's journey into RDF and the Semantic Web Stack.

If you don't have a preinstalled RDF graph database, no worries - we'll download an open source workbench called Blazegraph.

In this activity, you will download Blazegraph.

Here, we will go through the procedure for running Blazegraph and starting the workbench.

In this activity, you will run Blazegraph and explore the workbench.

In this lesson, you will start to author RDF data. You will see the importance of unique identification of resource nodes and predicates using IRIs, and ways to shorten IRIs using prefix shortcuts.

'RDF type' is an important construct in the RDF graph model, allowing simple groupings and categories of things to be captured. In this lesson, we will see how to declare triples that involve the 'RDF type' predicate.

In this lesson, we will complete all the triples surrounding Bugs Bunny, his creator and his debut appearance.

Note: The triples in this tutorial can be downloaded from Lecture 16.

The Turtle syntax is a human-friendly way of writing RDF data. It's almost like writing classic sentences and in this lecture, we'll make sure to identify this syntax and make the most of appropriate syntax highlighting in Blazegraph.

This activity will enable you to get hands-on with composing RDF data using the Turtle syntax.

Another illustration of writing good RDF data.

Note: The triples in this tutorial can be downloaded from Lecture 18.

Get hands-on with composing RDF data using the Turtle syntax.

Practice makes perfect! This activity will help you complete all the triples in the graph for the remaining Looney Tunes characters, their creators and debut appearances.

Once all the triples have been written down, it's now time to load the dataset into the graph database. In this lesson, we'll see the procedure on how to load the dataset in Blazegraph.

Note: The complete set of triples can be downloaded from Lecture 21.

In this activity, you will load the dataset into the graph database. In case you need to grab the RDF data in Turtle format, there's a handy text file attached containing all the triples we've composed so far.

In this lesson, we'll introduce how to compose a basic graph pattern to pull all the triples contained in the graph.

Pulling and displaying all the triples contained in the graph is not such a good idea in practice! For this reason, we can use the LIMIT modifier to surface a sample of triples as opposed to the whole dataset.

Test your knowledge of writing a basic graph pattern.

In this lecture, we'll explore a very simple one-hop query pattern.

This builds on top of the one-hop query pattern, where we'll attempt to find Bugs Bunny's creator.

Some more practice on the on-hop query pattern, where this time we'll be displaying more than one result in tabulated format.

Checkpoint to test your knowledge on composing a simple one-hop query pattern.

In this lesson, we'll see how to use the conjunction (.) symbol to compose more complex query patterns.

Test your knowledge of using conjunction (.) to match against more complex query patterns.

Learn a few tips on how to compose lean queries. The principles are very similar to how you compose in Turtle syntax.

Text your knowledge of pattern matching and writing lean queries.

This lecture will show you how to count things in the graph.

Test your knowledge of how to count things in the graph.

How do we remove duplicates from a list of results? It's super-easy and here, we'll show how to achieve this.

Test your knowledge of how to surface deduplicated results.

This lesson illustrates how to check for the non-existence or existence of graph patterns.

Test your knowledge of using the EXISTS clause.

In this lesson, we'll see how to break down a simple problem and write a query to discover characters who were co-created.

In this lecture, we expose how to use the MAX and MIN aggregate functions to determine the maximum and minimum values in a list.

Here, we'll see a simple example of performing a mathematical operation.

Test your knowledge of using BIND and performing a simple mathematical operation.

This lecture exposes a clever way of ordering and limiting a results set to analyse information.

Here we will get to see an example of using the AVG aggregate function for averaging values from a results set.

More advanced analysis of graph data sometimes involves the use of BIND and the IF conditional. In this lesson, we'll illustrate an example of achieving more complex analysis.

This lecture introduces the purpose of COALESCE and IF for writing lean queries where we need to run different tests.

Test your knowledge of using BIND, COALESCE and IF.

In this lecture, we'll go through another SPARQL construct for combining graph patterns - the OPTIONAL clause, which allows for optional matching results to be surfaced.

Test your knowledge of working with the OPTIONAL clause.

The UNION clause is another way of combining graph patterns in SPARQL. It basically allows for writing queries involving disjunction.

Test your knowledge of working with the UNION clause.

This lesson illustrates the use of the MINUS clause.

Aggregation through grouping is important in data analysis. The example in this lecture shows how to use the GROUP BY modifier.

Test your knowledge of using the GROUP BY modifier.

In SPARQL, there are other kinds of queries other SELECT queries. This lecture introduces the DESCRIBE query.

Test your knowledge of building a DESCRIBE query.

This lecture illustrates how to build an ASK query, which return True or False based on the pattern being queried.

Test your knowledge of writing an ASK query.

Building cool sub-graphs is made possible with the CONSTRUCT query. This lecture introduces this query.

This is a continuation of the previous lecture where we'll see how a more advanced example of crafting a CONSTRUCT query.

Test your knowledge of building the CONSTRUCT query.

This lecture introduces the concept of property paths and the ease with which SPARQL makes it possible to 'connect the dots' at scale and draw useful conclusions.

Thinking of reversing direction? No problem! Enter the 'inverse path'.

Breadcrumbs are not always helpful, as we know from the fairy tale 'Hansel and Gretel'! However, SPARQL lets you find your way back with 'sequence paths'. Sequence paths allow you to go from node A to node B through the chaining of predicates (i.e. routes you can follow).

Test your knowledge of using the inverse and sequence paths.

In this lesson, we'll take a look at recursive paths, which allows us to build queries involving arbitrary lengths triples.

This is a continuation of the previous lecture on 'recursive paths'.

This lecture will illustrate a query to list all possible paths you can take between a node A and a node B in a forward direction of travel. It's not a labyrinth after all!

Test your knowledge of property paths and writing a query to understand the possible paths you can take between two nodes.

SPARQL Update includes a set of operations for inserting and deleting specific triples, as well as inserting and deleting data based on graph patterns. In this lesson, we'll take a look at the INSERT DATA function.

This lecture covers the DELETE DATA function.

This lecture covers the INSERT function for adding new triples to the graph based on pattern matching. It is one of the mechanisms used in practice to build inference rules to automatically create new knowledge in an RDF graph.

Before you attempt this tutorial, please make sure to reload all the data by running a SPARQL update on the contents of the file reload-data-sparql-update.txt

Test your knowledge of using the INSERT function.

Here, we'll get to see an extended example of using the INSERT function.

Note: The insert query used in this tutorial can be downloaded in Lecture 75.

Test your knowledge further on using the INSERT function.

This lesson will cover the basics of the DELETE function for removing triples that conform to certain graph patterns.

A 'named graph' is a uniquely identifiable container for triples. This lecture introduces this topic.

In this tutorial, we'll get to see how to create a named graph.

After creating the named graph, we can then make it the default graph and query its contents. This lecture is about this technique for querying the triples in single named graphs as the default graph.

Test your knowledge of creating and querying a named graph.

This lessons covers the deletion of named graphs.

Test your knowledge of dropping a graph.

This lesson provides a boilerplate SPARQL query for retrieving all named graphs.

As you assemble triples and assign resource nodes a 'type', you indirectly create an underlying structure (a proto-ontology, so to speak). Revealing this latent underlying graph schema (or graph vocabulary) is important and this lecture introduces this topic.

In this lecture, we'll see how to surface the types of things that exist in the graph.

Here, we will illustrate a simple query to surface all the predicates used in the graph.

We can then combine the understanding from the previous two lectures to come up with a list of applicable predicates for every type of thing that exists in the graph.

Test your knowledge of building queries to surface the graph vocabulary.

Course summary.

This is the concluding lecture for this series. Hope you've enjoyed the course!

Download course slides.

Attributions, special thanks and disclaimer.