SPARQL introduction and training (130+ slides with exercices)

SPARQL
Thomas Francart,
Crédits : This work remixes, translates and complete a presentation from Fabien Gandon, INRIA, under an open licence. Thanks to him.
This work is placed under « Attribution ShareAlike 4.0 International ». You are free to share and adapt this work, even for commercial purposes.
You must give appropriate credit, provide a link to the license, and indicate if changes were made. If you remix, transform, or build upon the
material, you must distribute your contributions under the same license as the original. For more information, see the license.

RDF and its triples
is the first level (after URI)
in the standards of the
semantic web

SPARQL
is on top of RDF . It is a query
language and query protocol.
It is the SQL for RDF data.

SPARQL
• Query data
• Traverse graph from heterogeneous sources
• Consistency checking
• Data analytics
• Data management (copy, move, delete, etc.)
• Convert data from one structure to another
• Make some inferences : find new data/relations from
existing data
• Generate exports (tabular or graph)
• Make federated queries (query multiple databases) …

SPARQL limits
• No full-text search indexes (proprietary extensions)
• No geographical indexes (proprietary extensions)
• No query hints to control exécution plan (proprietary
extensions)
• No stored procedures
• No triggers

SPARQL standard has 3 parts
Part 1: query language syntax
Part 2: result format specification
Part 3: query protocol
6

Your first SPARQL
Basic Graph Patterns

Your first SPARQL
PREFIX ...
SELECT ...
WHERE { ... }

PREFIX clause
Declare “shortcuts” for
URIs used inside the
query

SELECT clause
Indicate which values
you want to return (which
columns)

WHERE Clause
The conditions to search
on the graph/the triples in
the RDF data

Triple patterns :
WHERE Clause
{ ?x rdf:type ex:Person .
?x ex:name ?name . }

Example – persons with their names
PREFIX ex: <http://foo.org/ontology#>
SELECT ?person ?name
WHERE {
?person rdf:type ex:Person .
?person ex:name ?name .
}

Patterns with 1 variable
# ?x that are Persons
?x rdf:type foaf:Person .
# ?x that Tom knows
ex:Tom foaf:knows ?x .
# ?x that link Tom and Oliver
ex:Tom ?x ex:Oliver .

Patterns with 2 variables
# ?x and ?y that know each other
?x foaf:knows ?y .
# All verbs and values about Tom
ex:Tom ?x ?y .
# All subject and verbs that link to Tom
?x ?y ex:Tom .

Patterns with 3 variables
… or no variable at all
# Everyting on everything !
# (returns all database)
?x ?y ?z .
# Tom is a Person
ex:Tom rdf:type foaf:Person .

Exemple – same query as before
WHERE {
?person a ex:Person ;
ex:name ?name .
}
Avoid confusion and always write full « sentences » :
- Subject verb complement dot
- …

Whitespace between subject / predicate / object
No whitespace in a URI or a variable name
Never put whitespace afer or before the “:” in prefixed URIs.
Never put whitespace after the “?” in variables !
If you want, a whitespace before final “.”
Whitespaces
?aPerson rdf:type foaf:Person .

WHERE {
# Don’t use foaf:Person
?person a ex:Person .
}
Comments

Methodology
Write your queries step by step and test at each
step :
• Add a first criteria
• Use LIMIT keyword to avoid too long result sets
• Test
• Add a criteria
• Test
• Add a criteria
• Etc.

Exercise 1 : a first query with a basic graph
patterns
• Write a query that returns…
• All the companies…
• … with their names
PREFIX dbo: <http://dbpedia.org/ontology/>
PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
…
• Company = dbo:Company
• Name = rdfs:label
http://dbpedia.org/sparql

Exercise 1 : a first query with a basic graph
patterns
SELECT ?x ?label
WHERE {
?x a dbo:Company .
?x rdfs:label ?label .
}

Methodology
Understanding and mastering the
structure of the underlying RDF
Knowledge Graph is fundamental
to query it in SPARQL.

Methodology
1. Look at notices of entities to understand their
description
In HTML or in RDF
2. And/or read the model documentation
3. And/or look at sample queries provided
4. And/or do SPARQL exploration queries (see annex)
It is possible to discover the graph data model by issuing specific
SPARQL queries
5. Draw graph sketches

Exercise 2 : A basic graph pattern that
traverses the graph
• All the companies with their names…
• … that have been founded by someone …
• … born in a place …
• … that is in the United States
PREFIX dbr: <http://dbpedia.org/resource/>
• founded by = dbo:founder
• Born in = dbo:birthPlace
• In country : dbo:country
• United States : dbr:United_States

Exercise 2 : A basic graph pattern that
traverses the graph
SELECT ?x ?label
WHERE {
?x a dbo:Company .
?x dbo:owner ?owner .
?owner dbo:birthPlace ?somewhere .
?somewhere dbo:country dbr:United_States
}

DISTINCT
SELECT DISTINCT ?x ?y
Deduplicate the result set

Sorting and paging
ORDER BY ?x variable(s) to
order on. Use DESC(?x) to sort from Z-A
LIMIT 100 limit the total size of
result set
OFFSET 10 index of the first result in
total result set
All identical to SQL

Exemple – results 21 to 40 sorted by name
WHERE {
}
ORDER BY ?name
LIMIT 20
OFFSET 20

Functions and FILTERS
Beyond Basic Graph Patterns

Functions
Functions are applied on variables. They are
used to :
1. FILTER the values of variables we want
FILTER(lang(?x) = "fr")
2. Change the content of a column in the
result set (assignation – see later)

FILTER
Add constraints on the
variables used in the graph
pattern : FILTER(?x > 18)

WHERE {
?person ex:age ?age .
FILTER (?age > 18)
}
Exemple – person above 18

Mathematical
operators
+, -, *, /, =, !=, >, <, >=, <=

Boolean operators
!, &&, ||
FILTER(
?x = <http://aaa> ||
?x = <http://bbb>
)

Functions on RDF
literals / resources
lang(?x) : language of ?x (« fr »)
str(?x) : string value of ?x (without
language/datatype)
datatype(?x) : datatype of ?x

Exercice 3 : Using FILTER
• Keep only the names of the companies in
English

Exercice 3 : Using FILTER
SELECT ?x ?label
WHERE {
?x a dbo:Company .
FILTER(lang(?label) = "en")
}

SELECT (f(?x) AS ?y)
In the SELECT clause, you can
apply a function on a variable
and assign the result to a new
variable with AS.
This is assignation – more on this later

Exercise 4 : Using a function in the SELECT
clause with AS
• We would like to get rid of the « @en » of
the label column in the result set
• Use « str(?label) » in the SELECT clause
to select only the label string without the
language

Exercise 4 : Using a function in the SELECT
clause with AS
SELECT ?x (STR(?label) AS ?theLabel)
WHERE {
?x a dbo:Company .
}

Functions on RDF
literals / resources
isIRI(?x) : true if ?x is an IRI
isLiteral(?x) : true if ?x is a literal
isBlank(?x) : true if ?x is an
anonymous node

Functions on strings
UCASE(?x) / LCASE(?x) : ?x in upper-case /
lower case
STRLEN(?x) : length of ?x
STRSTARTS(?x, ?y) STRENDS(?x,
?y) CONTAINS(?x, ?y) : test if ?x starts with
/ ends with / contains ?y

STRBEFORE(?x,"foo") /
STRAFTER(?x,"foo") : substring after of
before « foo » in ?x
REPLACE(?x,"http","https") :
replaces « http » with « https » in ?x
Functions on strings

If « test » is true, returns
« then », otherwise returns
« else »
IF(<test>,<then>,<else>)

Combine functions
FILTER(CONTAINS(STR(?x), "foo"))
test if the string value of ?x contains « foo »

Combine functions
FILTER(IF(STRLEN(?name) > 10, BIND(…),
BIND(…)))
FILTER(STRLEN(STRBEFORE(?name, "b")) > 10)
FILTER(
IF(CONTAINS(STRAFTER(LCASE(?name),
"mr."),"tom"),…,…)
)

YEAR(?x) / MONTH(?x) / DAY(?x)
/ HOURS(?x) / MINUTES(?x) /
SECONDS(?x)
Extracts part of a date value
FILTER(YEAR(?x) = 2020)
Functions on dates

IN / NOT IN
IN(…) and NOT IN(…)
FILTER(?x IN (ex:Tom, ex:Oliver,
ex:Franck))
FILTER(?x NOT IN ("a", "b", "c"))

REGEX() function
regex(?x, "^tom", "i")
1. Variable to test
2. Regular expression
3. Options (« i » : case-insensitive)

Starts with « tom » regex(?x, "^tom", "i")
Ends with « tom » regex(?x, "tom$", "i")
Contains a number regex(?x, "[0-9]")
Contains only a number regex(?x, "^[0-9]$")
Contains date in format JJ/MM/AAAA or
JJ-MM-AAAA (with day or month in or or
two caracters)
regex(?x, "[0-9][0-9]?[/-][0-
9][0-9]?[/-][0-9][0-9][0-9][0-
9]")
Starts with http:// or https:// regex(?x, "^https?://[^s]+$")
…

Character Legend Example Sample Match
d
Most engines: one digit
from 0 to 9
file_dd file_25
w
Most engines: "word character": ASCII letter, digit or
underscore
w-www A-b_1
s
Most engines: "whitespace character": space, tab,
newline, carriage return, vertical tab
asbsc
a b
c
D
One character that is not a digit as defined by your
engine's d
DDD ABC
W
One character that is not a word character as defined by
your engine's w
WWWWW *-+=)
S
One character that is not a whitespace character as
defined by your engine's s
SSSS Yoyo
Quantifier Legend Example Sample Match
+ One or more Version w-w+ Version A-b1_1
* Zero or more times A*B*C* AAACC
? Once or none plurals? plural
{3} Exactly three times D{3} ABC
{2,4} Two to four times d{2,4} 156
{3,} Three or more times w{3,} regex_tutorial

. Any character except line break a.c abc
.
Any character except line break, any number
of times
.* whatever, man.
.
A period (special character: needs to be
escaped by a )
a.c a.c
Escapes a special character .*+? $^/ .*+? $^/
Escapes a special character [{()}] [{()}]
[ … ] One of the characters in the brackets [AEIOU] One uppercase vowel
[ … ] One of the characters in the brackets T[ao]p Tap or Top
- Range indicator [a-z] One lowercase letter
[x-y] One of the characters in the range from x to y [A-Z]+ GREAT
[ … ] One of the characters in the brackets [AB1-5w-z]
One of either:
A,B,1,2,3,4,5,w,x,y,z
[x-y] One of the characters in the range from x to y [ -~]+
Characters in the printable
section of the ASCII table.
[^x] One character that is not x [^a-z]{3} A1!
[^x-y]
One of the characters not in the range from x
to y
[^ -~]+
Characters that are not in the
printable section of the ASCII
table.

Combining Graph
Patterns
Negative patterns / Optional patterns / Union of
patterns

OPTIONAL
Make one or more query
patterns optional
Even if they don’t match, results will still
be returned.
Very useful to build result sets when we
are not 100% all properties exist

Exemple – return age if it is know in the graph
SELECT ?person ?name ?age
WHERE {
OPTIONAL { ?person ex:age ?age }
}

Exercise 5 : Making some patterns optional
• … and their slogan if they have one !
• Slogan : dbo:slogan

Exercise 5 : Making some patterns optional
SELECT ?x ?label ?slogan
WHERE {
?x a dbo:Company .
OPTIONAL { ?x dbo:slogan ?slogan }
}

NOT EXISTS / MINUS
Make some query patterns
negative.
“I am looking for resources that don’t have …”
“I am looking for all resources that have this
minus those that have that”

Exemple – persons who don’t know Tom (FILTER
NOT EXISTS)
SELECT ?person
WHERE {
FILTER NOT EXISTS {
?person ex:knows ex:Tom .
}
}

Exemple – persons except those that know Tom
(MINUS)
SELECT ?person
WHERE {
MINUS {
?person ex:knows ex:Tom .
}
}

NOT EXISTS / MINUS
There are subtle differences
between FILTER NOT EXISTS
and MINUS

SELECT * WHERE {
?s ?p ?o
FILTER NOT EXISTS
{ ?x ?y ?z }
}
0 results
PREFIX ex: <http://ex.fr/>
SELECT * WHERE {
?s ?p ?o
FILTER NOT EXISTS
{ ex:A ex:B ex:C }
}
0 results
SELECT * WHERE {
?s ?p ?o
MINUS
{ ?x ?y ?z }
}
All results
PREFIX ex: <http://ex.fr/>
SELECT * WHERE {
?s ?p ?o
MINUS
{ ex:A ex:B ex:C }
}
All results

Exercise 6 : Making some patterns negative
• … for those that do NOT have a slogan
• Slogan : dbo:slogan

Exercise 6 : Making some patterns negative
SELECT ?x ?label
WHERE {
?x a dbo:Company .
FILTER NOT EXISTS { ?x dbo:slogan ?slogan }
}

UNION
Give alternatives query
patterns in a query
(a Boolean “OR” between query
patterns).
Rarely used in practice

Exemple – implicit or explicit Adults
SELECT ?name
WHERE {
{
{ ?person rdf:type ex:Adult }
UNION
{ ?person ex:age ?age .
FILTER (?age > 18) }
}
}

Traversing the graph with
property paths
?x foaf:knows/org:membership/org:organization
ex:MinistryOfJustice

Property paths
Easily traverse/navigate
the graph. Similar to Xpath
in XML

Exemple – Persons who are friends of a friends of
Tom
SELECT ?person
WHERE {
?person rdf:type ex:Person ;
ex:knows/ex:knows ex:Tom .
}
?x Ex:Tom
ex:knows ex:knows

ex:knows/ex:livesIn
ex:knows followed by ex:livesIn
ex:knows|ex:marriedWith
ex:knows or ex:marriedWith
!ex:knows
any property except ex:knows
ex:Tom ^ex:knows ?x :
ex:knows from ?x to ex:Tom
(to be combined with “/” paths)

ex:Tom ex:knows+ ?x
All ?x that Tom knows, and friends of friends of
friends… recursively, including ex:Tom
ex:Tom ex:knows* ?x
All ?x that Tom knows, and friends of friends of
friends… recursively, not including ex:Tom
ex:Tom ex:knows? ?x
Tom and any person he knows
(...)
Combine operators

Exemple Query ancestors of Tom
?ancestor (ex:motherOf|ex:fatherOf)+ ex:Tom
?c1 skos:broader|^skos:narrower ?c2
Exemple Querying inverse links
Exemple Querying RDF lists
?c1 rdf:rest*/rdf:first ?c2

Exercise 7 : Using property paths to traverse /
navigate the graph
• All the companies with their names…
• … that have been founded by someone …
• … born in a place …
• … that is in the United States
• Use a property path

Exercise 7 : Using property paths to traverse /
navigate the graph
SELECT ?x ?label
WHERE {
?x a dbo:Company .
?x dbo:owner/dbo:birthPlace/dbo:country dbr:United_States
}

Assignation
(?x AS ?y) / BIND(?x AS ?y)

Assignation allows to set the
value of a variable with :
• result of a computation
• result of a function
• result of an aggregation function (GROUP BY)
• a (list of) value(s) known in advance

Exemple – Compute “body mass index”
SELECT ?person ((?w/(?h*?h)) AS ?BMI)
WHERE {
?person a ex:Person ;
ex:height ?h .
ex:weight ?w .
}

Assignation can be done in
SELECT or in WHERE by using
the BIND operator to reuse the
value elsewhere

Exemple – Persons with low BMI
SELECT ?person ?BMC
WHERE {
?person ex:weight ?w .
?person ex:height ?h .
BIND((?w/(?h*?h)) AS ?BMC)
FILTER (?BMC < 25)
}

Aggregation functions
enable to make computations
like COUNT, MAX, MIN, etc. and
can be combined with GROUP
BY.

Exemple – Number of Persons with low BMI
SELECT (COUNT(?person) as ?count)
WHERE {
ex:weight ?w ;
ex:height ?h .
FILTER ((?w/(?h*?h)) < 25)
}

Exemple – Number of Persons with low BMI per
country
SELECT ?country (COUNT(?person) as ?count)
WHERE {
ex:weight ?w ;
ex:height ?h .
?person ex:livesIn ?country .
FILTER ((?w/(?h*?h)) > 25)
} GROUP BY ?country

Aggregation functions :
COUNT, SUM, MIN, MAX, AVG,
SAMPLE et GROUP_CONCAT.

Exemple – Concatenate all names of friends of
Tom in a single string
SELECT (GROUP_CONCAT(?nameOfFriend; separator=“,”) AS
?allNamesOfFriends)
WHERE {
ex:Tom ex:knows/ex:name ?nameOfFriend .
}

HAVING keyword enables to
set a criteria on a group of the
GROUP BY clause, using
aggregates
Rarely used in practice

Exemple – Number of persons with low BMC per
country, for country with average BMC < 20
SELECT ?country (COUNT(?person) as ?count)
WHERE {
?person a ex:Person ; ex:weight ?w ;
ex:height ?h ; ex:livesIn ?country .
BIND ((?w/(?h*?h)) AS ?IMC)
FILTER(?IMC > 25)
} GROUP BY ?country
HAVING (AVG(?IMC) > 20)

VALUES is a very useful
keyword to directly assign the
values of certain variables. It
enable to pass list of values in
the query

Exemple – Read 3 known person names
WHERE {
VALUES ?person {
ex:Tom ex:Oliver ex:Mark
}
}

VALUES and FILTER(…
IN(…)) are NOT equivalents
« FILTER IN » is applied after pattern
matching, VALUES is applied during
it.
VALUES is more performant
than « FILTER IN ».

Subqueries & federated
queries

Nested queries are
SELECT subqueries
inside the WHERE
clause.
Use-case 1 : limit / sort / aggregate a subset
Use-case 2 : control the order of exécution of the
query

Exemple – Read top ten most used keywords,
then read their labels
SELECT ?cpt ?label
WHERE {
{
SELECT DISTINCT ?cpt
WHERE {
?doc dcterms:subject ?cpt .
}
ORDER BY DESC(COUNT(?cpt) as ?c)
LIMIT 10
}
?cpt skos:prefLabel ?label
}

Nested queries are
always executed before
the rest of the clauses.
This enables to control the execution
order of the query

It is possible to combine the
results of multiple SPARQL
services with the SERVICE
keyword. This is federated
querying.

Exemple – Read country names from DBPedia, then select
the concepts from a thesaurus having the same label
PREFIX skos: <http://www.w3.org/2004/02/skos/core#>
PREFIX rdfs:<http://www.w3.org/2000/01/rdf-
schema#>
SELECT ?concept
WHERE {
?concept skos:prefLabel ?countryName .
SERVICE <http://dbpedia.org/sparql> {
?country rdfs:label ?countryName .
?country a <http://dbpedia.org/ontology/Country>
}
}

Be careful of the joins when querying an
remote database. Do not write :
SELECT ?person ?countryName
WHERE {
?country rdfs:label ?countryName
}}

Use sub-queries to garantee the order of
exécution of the queries. Write instead :
SELECT ?country ?countryName
WHERE {
{
SELECT DISTINCT ?country WHERE {
}
}
?country rdfs:label ?countryName
}}

Querying Named Graphs
« La quatrième dimension »

GRAPH
Allows patterns to be searched in
a subset of the complete data. A
graph is identified by a URI.
By default, without GRAPH, patterns are
searched in all graphs.

Exemple – keywords used in “production data”
PREFIX …
SELECT ?document ?tag ?label
WHERE {
GRAPH ex:baseProd {
?document dcterms:subject ?tag
}
?tag skos:prefLabel ?label
}

Exemple – return all graphs
PREFIX …
SELECT DISTINCT ?g
WHERE {
GRAPH ?g {
?s ?p ?o
}
}

FROM
Sets the DEFAULT GRAPH in
which patterns without a GRAPH
clause are searched.

SPARQL with FROM
PREFIX ...
SELECT ...
FROM ...
WHERE { ... }

Exemple – keywords from “test data” and
“production data”
PREFIX …
SELECT DISTINCT ?tag
FROM ex:baseProd
FROM ex:baseTest
WHERE {
?document dcterms:subject ?tag
}

FROM NAMED
Restricts the NAMED GRAPHS
available in GRAPH clauses.
Rarely used in practice.

Exemple – keywords from “test data” and
“production data” with their source
PREFIX …
SELECT ?doc ?tag ?g
FROM NAMED ex:baseProd
FROM NAMED ex:baseTest
WHERE
{
GRAPH ?g {
?doc dcterms:subject ?tag
}
}

Other forms of SPARQL
queries
CONSTRUCT / ASK / DESCRIBE

CONSTRUCT
Retourne un graphe RDF
pour chaque résultat
plutôt que des tuples

Exemple – return adults for persons over 18
CONSTRUCT
{
?person rdf:type ex:Adult
}
WHERE
{
?person ex:age ?age
FILTER (?age > 18)
}

Exemple – extract triples of age of persons
CONSTRUCT
{
?person ex:age ?age
}
WHERE
{
?person ex:age ?age
}

ASK
Test the existence of a
condition and simply
returns « true » / « false »
For consistency checking – but not much
used in practive. Use a SELECT most of
the time

Exemple – Are there any person over 18 ?
ASK
{
?person ex:age ?age
FILTER (?age > 18)
}

DESCRIBE
Give the « description »
(set of triples) of a
resource.
Typically, triples that have the URI(s) as
subject, + the labels of the object resources

Exemple – Describe persons over 18
DESCRIBE ?person
{
?person ex:age ?age
FILTER (?age > 18)
}

Exemple – Describe this known person
DESCRIBE <http://foo.org/~thomas#me>

Annex : queries to discover
the graph structure

1. List all types
SELECT DISTINCT ?type
WHERE {
?x rdf:type ?type .
}

2. List instances
SELECT ?x
WHERE {
?x rdf:type foaf:Person.
}

3. Everything about
SELECT ?p ?o
WHERE {
ex:Tom ?p ?o .
}
DESCRIBE ex:Tom

List all properties
SELECT DISTINCT ?p
WHERE { ?s ?p ?o . }
Be careful about performances

Properties per classes
SELECT DISTINCT ?type ?p
WHERE {
?x a ?type .
?x ?p ?o . FILTER(?p != rdf:type)
}
ORDER BY ?type

Annex : Creating URIs
and literals on-the-fly

One can forge IRIs and literals
and assign them :
IRI(string) : Builds an IRI from a string
ENCODE_FOR_URI(string) : escape a string to put in an
IRI
STR(literal) : string value of a literal or IRI as a
string
STRLANG and STRDT : build literals with value +
language or value + datatype

Exemple – Generate URIs from labels
SELECT ?newIRI
WHERE {
BIND(
IRI(CONCAT(
“http://sparna.fr/”,
ENCODE_FOR_URI(?name)
))
AS ?newIRI)
}

One can cast values from one
type to another using Xpath
constructors
xsd:boolean(?x), xsd:double(?x),
xsd:float(?x), xsd:decimal(?x),
xsd:integer(?x), xsd:dateTime(?x),
xsd:string(?x)

Exemple – Add one to a literal string value
SELECT
(
(xsd:integer(?age) + 1) AS
?ageAnneeProchaine
)
WHERE {
?person ex:age ?age .
}

Annex : SPARQL protocol
and result format

SPARQL Protocol
Standardizes the way to
issue queries to a
triplestore
Unlike SQL. Consequence : you can
switch database implementation
transparently

Exemple – HTTP query following SPARQL
protocol
GET /sparql/?query=<encoded query> HTTP/1.1
Host: dbpedia.org
User-agent: my-sparql-client/0.1

The result format in XML
<?xml version="1.0"?>
<sparql xmlns="http://www.w3.org/2005/sparql-results#" >
<head>
<variable name="person"/>
<variable name="name"/>
</head>
<results ordered="false" distinct="false">
<result>
<binding name="person">
<uri>http://inria.fr/schema#fg</uri>
</binding>
<binding name="name">
<literal>gandon</literal>
</binding>
</result>
<result> ...

The result format in JSON
{
"head": { "vars": [ "book" , "title" ]
} ,
"results": {
"bindings": [
{
"book": { "type": "uri" , "value": "http://example.org/book/book6" } ,
"title": { "type": "literal" , "value": "Harry Potter and the Half-Blood Prince" }
} ,
{
"title": { "type": "literal" , "value": "Harry Potter and the Deathly Hallows" }
} ,
{
"title": { "type": "literal" , "value": "Harry Potter and the Order of the Phoenix" }
} ,
{
"title": { "type": "literal" , "value": "Harry Potter and the Goblet of Fire" }
}
]
}
}

We neverdirectly see this
structure. It is always interpreted for us
by RDF/SPARQL libraries.

thomas.francart@
Web de
Structuration des
Accès aux
sparna.fr
données
informations
connaissances

SPARQL introduction and training (130+ slides with exercices)

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

Similaire à SPARQL introduction and training (130+ slides with exercices)

Similaire à SPARQL introduction and training (130+ slides with exercices) (20)

Plus de Thomas Francart

Plus de Thomas Francart (12)

Dernier

Dernier (20)

SPARQL introduction and training (130+ slides with exercices)