webapp.data.tutorial.workflow.ttl Maven / Gradle / Ivy
The newest version!
#
# Query definitions for a SPARQL tutorial based on a transformation
# To be used with /tutorial/rdf?profile=st:web
#
# Olivier Corby - Wimmics Inria I3S - 2015
#
# recall the dataset for the Transformation
st:tutorial a st:Dataset ;
st:data
[ st:uri "/data/tutorial/human1.rdf" ; st:name st:data1 ] ,
[ st:uri "/data/tutorial/human2.rdf" ; st:name st:data2 ] ,
[ st:uri "/data/tutorial/pragma.ttl" ; st:name st:pragma ] ;
# st:schema [ st:uri "/data/tutorial/human.rdfs" ; st:name st:schema ] ;
st:context [ st:uri "/data/tutorial/tutorial.ttl" ; st:name st:context ] .
us:sparql a sw:Workflow ;
sw:display true;
sw:debug true;
sw:collect true;
sw:body (
[ a sw:Query ;
st:name st:intro ;
rdfs:label "Introduction" ;
rdfs:comment """Choisissez une requête dans le sélecteur. 'Previous' et 'Next' permettent de naviguer dans les requêtes successives.
Une question est alors posée avec un canevas de réponse à compléter. En cliquant sur 'Solution', on obtient la réponse attendue, en cliquant sur 'Template', le canevas réapparaît. 'Submit' soumet la requête SPARQL au serveur. 'Dataset' donne accès au graphe RDF."""@fr ;
rdfs:comment """Choose a query in the selector. 'Previous' and 'Next' enable user to navigate in queries. When a query is selected, a query pattern is shown in the text area. 'Solution' displays the solution, 'Template' displays the query template. 'Submit' submits the SPARQL query to the server. 'Dataset' shows the RDF dataset of the tutorial."""@en ;
st:query ""
]
[ a sw:Query ;
st:name st:begin ;
rdfs:label "Triple Pattern" ;
rdfs:comment "Ecrire une requête qui retourne tous les triplets du graphe."@fr ;
rdfs:comment "Write a query that returns all triples"@en ;
st:query
"""select * where {
}""" ;
sw:body
"""select * where {
?x ?p ?y
}"""
]
[ a sw:Query ;
st:name st:type ;
rdfs:label "Type" ;
rdfs:comment "Retourner les instances du type h:Person."@fr ;
rdfs:comment "Return instances of type h:Person."@en ;
st:reference ;
st:query
"""prefix h:
select * where {
}""" ;
sw:body
"""prefix h:
select * where {
?x a h:Person
}"""
]
[ a sw:Query ;
st:name st:type2 ;
rdfs:label "Type" ;
rdfs:comment "Retourner les instances du type h:Person en utilisant la propriété rdf:type."@fr ;
rdfs:comment "Return instances of type h:Person using rdf:type property."@en ;
st:reference ;
st:query
"""prefix h:
select * where {
}""" ;
sw:body
"""prefix h:
select * where {
?x rdf:type h:Person
}"""
]
[ a sw:Query ;
st:name st:type3 ;
rdfs:label "Type" ;
rdfs:comment "Retourner les instances du type h:Person en écrivant l'URI complète du type."@fr ;
rdfs:comment "Return instances of type h:Person using the complete URI of the type (without prefix h:)."@en ;
st:reference ;
st:query
"""prefix h:
select * where {
}""" ;
sw:body
"""prefix h:
select * where {
?x a
}"""
]
[ a sw:Query ;
st:name st:type4 ;
rdfs:label "Type" ;
rdfs:comment "Retourner les instances du type h:Person en spécifiant la base et en utilisant une URI relative."@fr ;
rdfs:comment "Return instances of type h:Person using base and an URI."@en ;
st:reference ;
st:query
"""base
select * where {
?x a <#Person>
}"""
]
[ a sw:Query ;
st:name st:bgp ;
rdfs:label "BGP" ;
rdfs:comment "Retourne les instances de personne ayant un nom (h:name)."@fr ;
rdfs:comment "Return instances of person having a name (h:name)."@en ;
st:reference ;
st:query
"""prefix h:
select * where {
?x a h:Person
}""" ;
sw:body
"""prefix h:
select * where {
?x a h:Person ;
h:name ?n
}"""
]
[ a sw:Query ;
st:name st:bgp2 ;
rdfs:label "BGP" ;
rdfs:comment "Retourne les instances de Man ayant pour enfant (h:hasChild) i:Pierre et i:Jack."@fr ;
rdfs:comment "Return instances of Man having i:Pierre and i:Jack as child (h:hasChild)."@en ;
st:reference ;
st:query
"""prefix h:
prefix i:
select * where {
?x a h:Man
}""" ;
sw:body
"""prefix h:
prefix i:
select * where {
?x a h:Man ;
h:hasChild i:Pierre, i:Jack .
}"""
]
[ a sw:Query ;
st:name st:bnode ;
rdfs:label "Blank Node" ;
rdfs:comment "Trouver les personnes qui ont une valeur pour h:hasFriend en utilisant un blank node. "@fr ;
rdfs:comment "Find instances of person having a value for h:hasFriend using a blank node instead of a variable."@en ;
st:reference ;
st:query
"""prefix h:
select * where {
?x a h:Person
}""" ;
sw:body
"""prefix h:
select * where {
?x a h:Person ;
h:hasFriend []
}"""
]
[ a sw:Query ;
st:name st:pvariable ;
rdfs:label "Property Variable" ;
rdfs:comment "Trouver les valeurs des propriétés des instances de personne. "@fr ;
rdfs:comment "Find property values of instances of person."@en ;
st:query
"""prefix h:
select * where {
?x a h:Person
}""" ;
sw:body
"""prefix h:
select * where {
?x a h:Person ;
?p ?v
}"""
]
[ a sw:Query ;
st:name st:pvariable2 ;
rdfs:label "Property Variable" ;
rdfs:comment "Trouver des ressources différentes qui ont même valeur pour une même propriété. "@fr ;
rdfs:comment "Find different resources with same value for same property."@en ;
st:query
"""prefix h:
select * where {
}""" ;
sw:body
"""prefix h:
select * where {
?x ?p ?v .
?y ?p ?v .
filter (strstarts(?p, h:))
filter(?x != ?y)
}"""
]
[ a sw:Query ;
st:name st:list ;
rdfs:label "List" ;
rdfs:comment """Enumérer les trois éléments d'une liste."""@fr ;
rdfs:comment """Enumerate elements of a list with 3 elements."""@en ;
st:reference ;
st:query
"""prefix h:
select * where {
?x h:list ( )
}
""" ;
sw:body
"""prefix h:
select * where {
?x h:list (?a ?b ?c)
}
"""
]
[ a sw:Query ;
st:name st:list2 ;
rdfs:label "List" ;
rdfs:comment """Enumérer les trois éléments d'une liste avec rdf:first et rdf:rest."""@fr ;
rdfs:comment """Enumerate elements of a list with 3 elements using rdf:first and rdf:rest"""@en ;
st:reference ;
st:query
"""prefix h:
select * where {
?x h:list ?l
}
""" ;
sw:body
"""prefix h:
select * where {
?x h:list ?l .
?l rdf:first ?a ;
rdf:rest ?r1 .
?r1 rdf:first ?b ;
rdf:rest ?r2 .
?r2 rdf:first ?c ;
rdf:rest rdf:nil .
}
"""
]
[ a sw:Query ;
st:name st:count ;
rdfs:label "Count" ;
rdfs:comment """Compter le nombre de solutions avec un opérateur d'aggrégation."""@fr ;
rdfs:comment """Count the number of results using an aggregate operator."""@en ;
st:reference ;
st:query
"""prefix h:
select where {
?x ?p ?y
}""" ;
sw:body
"""prefix h:
select (count(*) as ?c) where {
?x ?p ?y
}"""
]
[ a sw:Query ;
st:name st:group ;
rdfs:label "Group By" ;
rdfs:comment """Compter le nombre de solutions. Retourner un résultat pour chaque valeur de ?x."""@fr ;
rdfs:comment """Count the number of solutions. Return one result for each value of ?x."""@en ;
st:reference ;
st:query
"""prefix h:
select ?x (count(*) as ?c) where {
?x h:hasChild ?y
}
""" ;
sw:body
"""prefix h:
select ?x (count(*) as ?c) where {
?x h:hasChild ?y
}
group by ?x
"""
]
[ a sw:Query ;
st:name st:gconcat ;
rdfs:label "Group concat" ;
rdfs:comment """Concaténer la liste des noms (?n) pour chaque valeur de ?x."""@fr ;
rdfs:comment """Concatenate the list of names (?n) for each value of ?x."""@en ;
st:reference ;
st:query
"""prefix h:
select ?x where {
?x h:hasChild ?y .
?y h:name ?n
}
group by ?x
""" ;
sw:body
"""prefix h:
select ?x (group_concat(?n) as ?l) where {
?x h:hasChild ?y .
?y h:name ?n
}
group by ?x
"""
]
[ a sw:Query ;
st:name st:having ;
rdfs:label "Having" ;
rdfs:comment """Compter le nombre de solutions. Retourne un résultat pour chaque valeur de ?x dont le compteur est > 1."""@fr ;
rdfs:comment """Count the number of solutions, return results where value of counter > 1."""@en ;
st:reference ;
st:query
"""prefix h:
select ?x (count(*) as ?c) where {
?x h:hasChild ?y
}
group by ?x
""" ;
sw:body
"""prefix h:
select ?x (count(*) as ?c) where {
?x h:hasChild ?y
}
group by ?x
having (count(*) > 1)
"""
]
[ a sw:Query ;
st:name st:order ;
rdfs:label "Order By" ;
rdfs:comment "Retourner les ressources instance de type personne, triées par ordre alphabétique."@fr ;
rdfs:comment "Return instances of person in alphabetical order."@en ;
st:reference ;
st:query
"""prefix h:
select * where {
?x a h:Person ;
h:name ?n
}
""" ;
sw:body
"""prefix h:
select * where {
?x a h:Person ;
h:name ?n
}
order by ?n
"""
]
[ a sw:Query ;
st:name st:distinct ;
rdfs:label "Distinct" ;
rdfs:comment "Retourner des résultats distincts."@fr ;
rdfs:comment "Return distinct results."@en ;
st:reference ;
st:query
"""prefix h:
select ?x ?y where {
?x ?p ?v .
?y ?p ?v
filter (?p = h:shoesize || ?p = h:shirtsize)
filter (?x != ?y)
}
order by ?x ?y""" ;
sw:body
"""prefix h:
select distinct ?x ?y where {
?x ?p ?v .
?y ?p ?v
filter (?p = h:shoesize || ?p = h:shirtsize)
filter (?x != ?y)
}
order by ?x ?y"""
]
[ a sw:Query ;
st:name st:distinct2 ;
rdfs:label "Distinct" ;
rdfs:comment "Eliminer les doublons en remplaçant l'opérateur != par <."@fr ;
rdfs:comment "Eliminate 'duplicate' results by replacing != by <."@en ;
st:reference ;
st:query
"""prefix h:
select distinct ?x ?y where {
?x ?p ?v .
?y ?p ?v
filter (?p = h:shoesize || ?p = h:shirtsize)
filter (?x != ?y)
}
order by ?x ?y""" ;
sw:body
"""prefix h:
select distinct ?x ?y where {
?x ?p ?v .
?y ?p ?v
filter (?p = h:shoesize || ?p = h:shirtsize)
filter (?x < ?y)
}
order by ?x ?y"""
]
[ a sw:Query ;
st:name st:filter ;
rdfs:label "Filter" ;
rdfs:comment """A l'aide d'un filtre, retourner les ressources avec un nom qui contient la lettre 'l'."""@fr ;
rdfs:comment """Return resources with name containing letter 'l'."""@en ;
st:reference ;
st:query
"""prefix h:
select * where {
?x h:name ?n
}
""" ;
sw:body
"""prefix h:
select * where {
?x h:name ?n
filter (contains(?n, "l"))
}
"""
]
[ a sw:Query ;
st:name st:lang ;
rdfs:label "Language" ;
rdfs:comment """Retourner les ressources ayant un nom taggé en français."""@fr ;
rdfs:comment """Return resources with name tagged in french."""@en ;
st:reference ;
st:query
"""prefix h:
select * where {
?x h:name ?n
}
""" ;
sw:body
"""prefix h:
select * where {
?x h:name ?n
filter (lang(?n) = "fr")
}
"""
]
[ a sw:Query ;
st:name st:lang2 ;
rdfs:label "Language" ;
rdfs:comment """Retourner la ressource dont le nom est le littéral 'Sophie' taggé en français."""@fr ;
rdfs:comment """Return resources with name 'Sophie' tagged in french."""@en ;
st:reference ;
st:query
"""prefix h:
select * where {
?x h:name "Sophie"
}
""" ;
sw:body
"""prefix h:
select * where {
?x h:name "Sophie"@fr
}
"""
]
[ a sw:Query ;
st:name st:datatype ;
rdfs:label "Datatype" ;
rdfs:comment """Retourner les datatypes des littéraux."""@fr ;
rdfs:comment """Return datatype of literals."""@en ;
st:reference ;
st:query
"""prefix h:
select * where {
?x ?p ?v
filter (strstarts(?p, h:))
filter (isLiteral(?v))
}
""" ;
sw:body
"""prefix h:
select * (datatype(?v) as ?d) where {
?x ?p ?v
filter (strstarts(?p, h:))
filter (isLiteral(?v))
}
"""
]
[ a sw:Query ;
st:name st:datatype2 ;
rdfs:label "Datatype" ;
rdfs:comment """RDF et SPARQL peuvent gérer des datatypes arbitraires."""@fr ;
rdfs:comment """Arbitrairy datatypes."""@en ;
st:reference ;
st:query
"""prefix h:
select * where {
?x h:phoneNumber ?n
}
"""
]
[ a sw:Query ;
st:name st:cast ;
rdfs:label "Cast" ;
rdfs:comment """Retourner la valeur de l'age castée en string."""@fr ;
rdfs:comment """Return age value casted as a string."""@en ;
st:reference ;
st:query
"""prefix h:
select * where {
?x h:age ?a
}
""" ;
sw:body
"""prefix h:
select * (xsd:string(?a) as ?s) where {
?x h:age ?a
}
"""
]
[ a sw:Query ;
st:name st:date ;
rdfs:label "Date" ;
rdfs:comment """Décomposer la date en année, mois, jour, heure, minute et seconde."""@fr ;
rdfs:comment """Decompose the date as year, month, day, hour, minute, second."""@en ;
st:reference ;
st:query
"""select (now() as ?n)
(year(?n) as ?ye)
where {
}
""" ;
sw:body
"""select (now() as ?n)
(year(?n) as ?ye)
(month(?n) as ?mo)
(day(?n) as ?da)
(hours(?n) as ?ho)
(minutes(?n) as ?mi)
(seconds(?n) as ?se)
where {
}
"""
]
[ a sw:Query ;
st:name st:regex ;
rdfs:label "Regex" ;
rdfs:comment """Retourner les URI qui matchent une expression régulière."""@fr ;
rdfs:comment """Return URI that match a regular expression."""@en ;
st:reference ;
st:query
"""prefix h:
select *
where {
?x a ?t
}
""" ;
sw:body
"""prefix h:
select *
where {
?x a ?t
filter (regex(str(?x), "inria.fr"))
}
"""
]
[ a sw:Query ;
st:name st:if ;
rdfs:label "If Then Else" ;
rdfs:comment """Retourner 'adult' ou 'young' selon l'age."""@fr ;
rdfs:comment """Return 'adult' or 'young' according to age."""@en ;
st:reference ;
st:query
"""prefix h:
select *
where {
?x h:age ?a
}
""" ;
sw:body
"""prefix h:
select * (if (?a >= 18, "adult", "young") as ?s)
where {
?x h:age ?a
}
"""
]
[ a sw:Query ;
st:name st:in ;
rdfs:label "In" ;
rdfs:comment """Fixer la valeur de ?x à i:Lucas, i:Pierre ou bien i:Mark avec l'opérateur de liste in."""@fr ;
rdfs:comment """Test whether the value of ?x is i:Lucas, i:Pierre or i:Mark using the 'in' list operator."""@en ;
st:reference ;
st:query
"""prefix h:
prefix i:
select *
where {
?x h:age ?a
}
""" ;
sw:body
"""prefix h:
prefix i:
select *
where {
?x h:age ?a
filter (?x in (i:Lucas, i:Pierre, i:Mark))
}
"""
]
[ a sw:Query ;
st:name st:union ;
rdfs:label "Union" ;
rdfs:comment """Retourner les instances de Man ou Woman."""@fr ;
rdfs:comment """Return instances of Man or Woman."""@en ;
st:reference ;
st:query
"""prefix h:
select * where {
{ ?x a h:Man } { ?x a h:Woman }
}
""" ;
sw:body
"""prefix h:
select * where {
{ ?x a h:Man } union { ?x a h:Woman }
}
"""
]
[ a sw:Query ;
st:name st:optional ;
rdfs:label "Optional" ;
rdfs:comment """Retourner les instances de Man ayant éventuellement un conjoint. """@fr ;
rdfs:comment """Return instances of Man possibly having a spouse."""@en ;
st:reference ;
st:query
"""prefix h:
select * where {
?x a h:Man
{ ?x h:hasSpouse ?s }
}
""" ;
sw:body
"""prefix h:
select * where {
?x a h:Man
optional { ?x h:hasSpouse ?s }
}
"""
]
[ a sw:Query ;
st:name st:optional2 ;
rdfs:label "Optional" ;
rdfs:comment """Retourner les instances de Man ayant éventuellement un conjoint et éventuellement un enfant. """@fr ;
rdfs:comment """Return instances of Man possibly having a spouse and possibly having child."""@en ;
st:reference ;
st:query
"""prefix h:
select * where {
?x a h:Man
{ ?x h:hasSpouse ?s }
{ ?x h:hasChild ?c }
}
""" ;
sw:body
"""prefix h:
select * where {
?x a h:Man
optional { ?x h:hasSpouse ?s }
optional { ?x h:hasChild ?c }
}
"""
][ a sw:Query ;
st:name st:optional3 ;
rdfs:label "Optional" ;
rdfs:comment """Retourner les instances de Man ayant éventuellement un conjoint et un enfant. """@fr ;
rdfs:comment """Return instances of Man possibly having a spouse and child."""@en ;
st:reference ;
st:query
"""prefix h:
select * where {
?x a h:Man
{ ?x h:hasSpouse ?s .
?x h:hasChild ?c }
}
""" ;
sw:body
"""prefix h:
select * where {
?x a h:Man
optional { ?x h:hasSpouse ?s .
?x h:hasChild ?c }
}
"""
][ a sw:Query ;
st:name st:optional4 ;
rdfs:label "Optional" ;
rdfs:comment """Retourner les instances de Person ayant éventuellement un age >= 18. """@fr ;
rdfs:comment """Return instances of Man possibly having age >= 18."""@en ;
st:reference ;
st:query
"""prefix h:
select * where {
?x a h:Person
{ ?x h:age ?a
}
}
""" ;
sw:body
"""prefix h:
select * where {
?x a h:Person
optional { ?x h:age ?a
filter (?a >= 18) }
}
"""
][ a sw:Query ;
st:name st:minus ;
rdfs:label "Minus" ;
rdfs:comment """Retourner les instances de Woman n'ayant pas de conjoint, en utilisant la clause minus. """@fr ;
rdfs:comment """Return instances of Woman not having a spouse using 'minus' clause. """@en ;
st:reference ;
st:query
"""prefix h:
select * where {
?x a h:Woman
}
""" ;
sw:body
"""prefix h:
select * where {
?x a h:Woman
minus { ?x h:hasSpouse ?s }
}
"""
][ a sw:Query ;
st:name st:minus2 ;
rdfs:label "Minus" ;
rdfs:comment """Retourne les instances de Woman ayant un conjoint. Minus ne fonctionne que s'il y a une variable commune entre les deux clauses du minus. Ici ce n'est pas le cas, d'où le fait que i:Flora est présente dans la solution. Pour corriger cela, remplacer i:Flora par la variable ?x."""@fr ;
rdfs:comment """Return instances of Man not having a spouse. Minus works when its two clauses share a common variable, which is not the case in the example below."""@en ;
st:reference ;
st:query
"""prefix h:
prefix i:
select * where {
?x a h:Woman ;
h:hasSpouse ?s
minus { i:Flora h:hasSpouse i:Gaston }
}
"""
][ a sw:Query ;
st:name st:exists ;
rdfs:label "Exists" ;
rdfs:comment """Retourner les instances de Man ayant un conjoint (h:hasSpouse), utiliser la clause filter exists. """@fr ;
rdfs:comment """Return instances of Man having a spouse using the 'filter exists' clause. """@en ;
st:reference ;
st:query
"""prefix h:
select * where {
?x a h:Man
}
""" ;
sw:body
"""prefix h:
select * where {
?x a h:Man
filter exists { ?x h:hasSpouse ?s }
}
"""
][ a sw:Query ;
st:name st:notexists ;
rdfs:label "Not Exists" ;
rdfs:comment """Retourner les instances de Man n'ayant pas de conjoint. """@fr ;
rdfs:comment """Return instances of Man not having a spouse. """@en ;
st:reference ;
st:query
"""prefix h:
select * where {
?x a h:Man
}
""" ;
sw:body
"""prefix h:
select * where {
?x a h:Man
filter not exists { ?x h:hasSpouse ?s }
}
"""
][ a sw:Query ;
st:name st:graph ;
rdfs:label "Named Graph" ;
rdfs:comment """Retourner le (ou les) graphe nommé dans lequel se trouvent des solutions."""@fr ;
rdfs:comment """Return named graph(s) where there are solutions."""@en ;
st:reference ;
st:query
"""prefix h:
select * where {
{
?x a h:Woman
}
}
""" ;
sw:body
"""prefix h:
select * where {
graph ?g {
?x a h:Woman
}
}
"""
][ a sw:Query ;
st:name st:graph2 ;
rdfs:label "Named Graph" ;
rdfs:comment """Interroger un graphe nommé dont l'URI est annotée avec une date (h:date)."""@fr ;
rdfs:comment """Return named graph(s) where the graph URI is annotated with a date (h:date)."""@en ;
st:reference ;
st:query
"""prefix h:
select * where {
graph ?g { ?x a h:Person }
}
""" ;
sw:body
"""prefix h:
select * where {
?g h:date ?d
graph ?g { ?x a h:Person }
}
"""
][ a sw:Query ;
st:name st:from ;
rdfs:label "From" ;
rdfs:comment """Spécifier le graphe nommé st:data1 pour constituer le graphe par défaut. """@fr ;
rdfs:comment """Specify the st:data1 named graph to form the default graph. """@en ;
st:reference ;
st:query
"""prefix h:
prefix st:
prefix st: ;
st:query
"""prefix h:
prefix st:
prefix st: ;
st:query
"""prefix h:
prefix st:
prefix st: ;
st:query
"""prefix h:
select * where {
{select
where {
?x h:age ?age
}}
?x h:age ?age
filter (?age in (?min, ?max))
}
""" ;
sw:body
"""prefix h:
select * where {
{select (max(?age) as ?max) (min(?age) as ?min)
where {
?x h:age ?age
}}
?x h:age ?age
filter (?age in (?min, ?max))
}
"""
][ a sw:Query ;
st:name st:bind ;
rdfs:label "Bind" ;
rdfs:comment """Avec la clause bind () créer une variable pour le résultat d'un calcul sur ?n, par exemple avec ucase."""@fr ;
rdfs:comment """Bind a variable for the result of a computation, for example compute and bind ucase(?n)."""@en ;
st:reference ;
st:query
"""prefix h:
select * where {
?x a h:Person ;
h:name ?n .
}
""" ;
sw:body
"""prefix h:
select * where {
?x a h:Person ;
h:name ?n .
bind (ucase(?n) as ?u)
}
"""
][ a sw:Query ;
st:name st:values ;
rdfs:label "Values" ;
rdfs:comment """Fixer les valeurs de la variable ?n à 'John', 'Alice' ou 'Lucas' avec la clause values."""@fr ;
rdfs:comment """Set value of variable ?n to 'John', 'Alice' or 'Lucas' using the values clause."""@en ;
st:reference ;
st:query
"""prefix h:
select * where {
?x h:name ?n
optional { ?x h:age ?a }
}
""" ;
sw:body
"""prefix h:
select * where {
?x h:name ?n
optional { ?x h:age ?a }
values ?n { "John" "Alice" "Lucas" }
}
"""
][ a sw:Query ;
st:name st:path ;
rdfs:label "Property Path" ;
rdfs:comment """Retourner les ressources reliées par un chemin de propriétés h:hasFriend. """@fr ;
rdfs:comment """Return resources related by a h:hasFriend property path. """@en ;
st:reference ;
st:query
"""prefix h:
select * where {
?x a h:Person .
}
""" ;
sw:body
"""prefix h:
select * where {
?x a h:Person .
?x h:hasFriend+ ?y
}
"""
][ a sw:Query ;
st:name st:path2 ;
rdfs:label "Property Path" ;
rdfs:comment """Retourner les ressources reliées par un chemin de propriétés h:hasFriend ou h:hasChild. """@fr ;
rdfs:comment """Return resources related by a property path with h:hasFriend or h:hasChild. """@en ;
st:reference ;
st:query
"""prefix h:
select * where {
?x a h:Person .
}
""" ;
sw:body
"""prefix h:
select * where {
?x a h:Person .
?x (h:hasFriend | h:hasChild)+ ?y
}
"""
][ a sw:Query ;
st:name st:dbpedia ;
rdfs:label "Service" ;
rdfs:comment """Interroger le SPARQL endpoint http://fr.dbpedia.org/sparql."""@fr ;
rdfs:comment """Query fr.dbpedia.org SPARQL endpoint."""@en ;
st:reference ;
st:query
"""select * where {
{
select * where {
?p ?y
}
limit 20
offset 20
}
}
""" ;
sw:body
"""select * where {
service {
select * where {
?p ?y
}
limit 20
offset 20
}
}
"""
][ a sw:Query ;
st:name st:construct ;
rdfs:label "Construct" ;
rdfs:comment """Transformer la requête pour construire un graphe résultat."""@fr ;
rdfs:comment """Construct a result graph."""@en ;
st:reference ;
st:query
"""prefix h:
select *
where {
?x a h:Person .
?x h:hasFriend+ ?y .
}
""" ;
sw:result sw:probe ;
sw:body
"""prefix h:
construct {
?x h:hasFriend ?y
}
where {
?x a h:Person .
?x h:hasFriend+ ?y .
}
"""
][ a sw:Query ;
st:name st:describe ;
rdfs:label "Describe" ;
rdfs:comment """Transformer la requête pour décrire la ressource ?x."""@fr ;
rdfs:comment """Describe resource ?x."""@en ;
st:reference ;
st:query
"""prefix h:
select ?x where {
?x h:age 12 .
}
""" ;
sw:result sw:probe;
sw:body
"""prefix h:
describe ?x where {
?x h:age 12 .
}
"""
][ a sw:Query ;
st:name st:ask ;
rdfs:label "Ask" ;
rdfs:comment """Transformer la requête pour répondre par vrai ou faux."""@fr ;
rdfs:comment """Answer true of false."""@en ;
st:reference ;
st:query
"""prefix h:
select * where
{
?x h:age 12 .
}
""" ;
sw:body
"""prefix h:
ask {
?x h:age 12 .
}
"""
#######################################################
][ a sw:Query ;
st:name st:anypath ;
rdfs:label "Property Path" ;
rdfs:comment """Retourner les ressources reliées à i:Gaston par un chemin constitué de n'importe quelle propriété. """@fr ;
rdfs:comment """Return resources related to i:Gaston by a property path with any property. """@en ;
st:reference ;
st:query
"""prefix h:
prefix i:
select * where {
i:Gaston ?pp ?y
filter isURI(?y)
}
""" ;
sw:body
"""prefix h:
prefix i:
select * where {
i:Gaston (! h:any)+ ?y
filter isURI(?y)
}
"""
][ a sw:Query ;
st:name st:listpp ;
rdfs:label "List Path" ;
rdfs:comment """Enumérer les éléments d'une liste avec un chemin sur les propriétés rdf:rest et rdf:first."""@fr ;
rdfs:comment """Enumerate list elements using a property path with rdf:first and rdf:rest."""@en ;
st:reference ;
st:query
"""prefix h:
select ?x ?e where {
?x h:list ?l
}
""" ;
sw:body
"""prefix h:
select ?x ?e where {
?x h:list ?l .
?l rdf:rest*/rdf:first ?e
}
"""
][ a sw:Query ;
st:name st:position ;
rdfs:label "List Position" ;
rdfs:comment """Enumérer les éléments d'une liste en donnant leur position dans la liste."""@fr ;
rdfs:comment """Enumerate list elements using a path with the elements position."""@en ;
st:reference ;
st:query
"""prefix h:
select ?x ?e (count(?mid) as ?pos) where {
?x h:list ?lst .
?node rdf:first ?e
}
group by ?node
order by ?pos
""" ;
sw:body
"""prefix h:
select ?x ?e (count(?mid) as ?pos) where {
?x h:list ?lst .
?lst rdf:rest* ?mid .
?mid rdf:rest* ?node .
?node rdf:first ?e
}
group by ?node
order by ?pos
"""
][ a sw:Query ;
st:name st:relevant ;
rdfs:label "Order by relevance" ;
rdfs:comment """Enumérer les résultats avec les solutions les plus complètes d'abord."""@fr ;
rdfs:comment """Enumerate results in order of most complete solutions first."""@en ;
st:reference ;
st:query
"""prefix h:
select * where {
?x a h:Person
optional { ?x h:name ?n }
optional { ?x h:shirtsize ?si }
optional { ?x h:shoesize ?so }
}
order by desc(?c)
""" ;
sw:body
"""prefix h:
select * where {
?x a h:Person
optional { ?x h:name ?n }
optional { ?x h:shirtsize ?si }
optional { ?x h:shoesize ?so }
bind (
if (bound(?n), 1, 0) +
if (bound(?si), 1, 0) +
if (bound(?so), 1, 0)
as ?c)
}
order by desc(?c)
"""
]
)
© 2015 - 2025 Weber Informatics LLC | Privacy Policy