Multiple operations can be packed into requests. Multiple operations must be separated by a ; (semicolon) character. A sequence of operations is terminated by either a semicolon or EOF (End of File). The operations of a request are executed in lexical order.
4.1 Graph Update
Graph update operations change existing graphs in the Graph Store but do
not explicitly delete nor create them. An implementation must create graphs
that do not exist before triples were inserted into them, and may remove
graphs that are left empty after triples are removed from them.
The INSERT DATA operation adds some triples, which are inline in the
request, into a graph. This will create the destination graph if it does not exist.
The DELETE DATA operation removes some triples, which are inline in
the request, from a graph.
The fundamental pattern-based operations for graph updates are INSERT and DELETE.
These operations consist of groups of triples to be deleted and
groups of triples to be added. The specification of the triples is based on
query patterns.
The difference between INSERT / DELETE
and INSERT DATA / DELETE DATA is that INSERT
DATA and DELETE DATA do not take a template and pattern. The
DATA forms require concrete data (no named variables).
Having specific operations means that a request can be streamed so that large,
pure-data, updates can be done.
The LOAD operation reads the contents of a document representing
a graph into a graph in the graph store.
The CLEAR operation removes all the triples in a graph.
4.1.1 INSERT DATA
Insert data into a graph:
INSERT DATA { graph_triples }
Graph triples are defined as:
graph_triples :: = TriplesBlock | GRAPH <graph_uri> { TriplesBlock }
If no graph is described in the graph_triples, then the default graph is presumed. If a graph is described, but it does not exist, then it will be created.
Note that a triple may be considered to be "processed" with no action if that triple already exists in the graph.
Example:
Adding some triples to a graph. This snippet
describes two RDF triples to be inserted into the default graph of the RDF store.
PREFIX dc: <http://purl.org/dc/elements/1.1/>
INSERT DATA
{ <http://example/book3> dc:title "A new book" ;
dc:creator "A.N.Other" .
}
4.1.2 DELETE DATA
Delete data from a graph:
DELETE DATA { graph_triples }
graph_triples are described in INSERT DATA.
Note that a triple may be considered to be "processed" with no action if that triple did not exist in the graph.
Example:
Removing undesired triples from a graph. This operation describes 2 triples to be removed from the default graph of the RDF store.
PREFIX dc: <http://purl.org/dc/elements/1.1/>
DELETE DATA
{ <http://example/bookx> dc:title "David Copperfield" ;
dc:creator "Edmund Wells" .
}Example:
This SPARQL 1.1 Update request expands on the previous examples, by including a triple to be deleted and a triple to be added (used here to correct a book title). Also, instead of using the default graph, the requested change happens in the named graph identified by the URI http://example/bookStore.
PREFIX dc: <http://purl.org/dc/elements/1.1/>
DELETE DATA
{ GRAPH <http://example/bookStore> { <http://example/book3> dc:title "Fundamentals of Compiler Desing" } } ;
PREFIX dc: <http://purl.org/dc/elements/1.1/>
INSERT DATA
{ GRAPH <http://example/bookStore> { <http://example/book3> dc:title "Fundamentals of Compiler Design" } }
4.1.3 DELETE/INSERT
[ WITH <uri> ]
DELETE { modify_template [ modify_template ]* }
INSERT { modify_template [ modify_template ]* }
[ USING [NAMED] <uri> ]*
[ WHERE ] GroupGraphPattern
The modify_template has the following form:
modify_template :: = ConstructTriples | graph_template
graph_template ::= GRAPH VarOrIRIRef { ConstructTriples }
The template and pattern forms are as defined in
SPARQL for
construct templates and
graph patterns.
This operation identifies data with the WHERE clause, binding values to a set of variables. These bindings are then used in the DELETE template to remove triples, and then in the INSERT template to create new triples.
The WITH uri defines the graph that will be modified or matched against
for any of the subsequent elements that do not specify a graph explicitly. If not provided, then the default graph of the store will be assumed.
Following the optional WITH clause are the INSERT
and DELETE directives. The deletion of the triples happens before the insertion. The pattern in the WHERE clause is evaluated only once, before the delete part of the operation is performed. The overall processing model is that the pattern is executed, the results used to instantiate the DELETE template, the deletes performed, the results used again to instantiate the INSERT template, and the inserts performed.
The USING <uri> and USING NAMED <uri> clauses affect the graphs and named graphs used in the WHERE clause. This is identical manner to how FROM <uri> and FROM NAMED <uri> clauses affect the graphs and named graphs in a SPARQL SELECT query. The use of USING in this instance is to avoid possible ambiguity of where statements being DELETEd from. If a USING clause appears, then this will override any effect that WITH may have on the WHERE clause, and only the WHERE clause.
As with SELECT queries, the GroupGraphPattern in the WHERE clause will be matched against any graphs described explicitly in that GroupGraphPattern, and any portions which do not specify a graph will be matched against the datasets described with USING or USING NAMED. Any remaining portions of the GroupGraphPattern which are not assigned a dataset will be matched against the graph specified in the WITH clause, if present, or the default graph otherwise.
The GroupGraphPattern is evaluated as in a SPARQL query "SELECT * WHERE GroupGraphPattern"
and all the named variables are made available to the preceding templates for defining the triples to be inserted or
deleted.
The GRAPH <uri> clause in a graph_template
names the graph in the graph store to be
updated; if omitted, the directive applies to the graph specified by the
WITH clause, or the default graph if no WITH clause is present.
To illustrate the use of the WITH clause, an operation of the general form:
WITH <g1> INSERT { x y z } DELETE { a b c } WHERE { ... }Is considered equivalent to:
INSERT { GRAPH <g1> { x y z } } DELETE { GRAPH <g1> { a b c } } USING <g1> WHERE { ... }Note that WITH will be ignored for any section that stipulates a GRAPH or for the entire WHERE clause if a USING is present.
Deleting triples that are not present, or from a graph that is not present will have no effect and will result in success.
If an operation tries to insert into a graph that does not exist, then that graph must be created.
If no data is to be inserted, then no graph will be created, even if another dataset would result in data being inserted.
If a graph must be created regardless of the data to be inserted, then the graph management operations (CREATE/LOAD) may be used prior to aniy insertion operations.
Example:
An example to update the graph http://example/addresses to rename all people with the name "Bill" to "William".
PREFIX foaf: <http://xmlns.com/foaf/0.1/>
WITH <http://example/addresses>
DELETE { ?person foaf:firstName 'Bill' }
INSERT { ?person foaf:firstName 'William' }
WHERE
{ ?person a foaf:Person .
?person foaf:firstName 'Bill'
}
4.1.4 DELETE
[ WITH <uri> ]
DELETE { modify_template [ modify_template ]* }
[ USING [NAMED] <uri> ]*
WHERE GroupGraphPattern
The DELETE operation is similar to the DELETE/INSERT
operation without an INSERT section.
If any DELETE template specifies a GRAPH then this will be the graph affected. Otherwise, the operation will be applied to the graph specified in the WITH clause, if one was specified, or the default graph otherwise.
The WHERE clause identifies data in existing graphs, and creates bindings to be used by the template. The graphs to apply the GroupGraphPattern to follow the same rules as for DELETE/INSERT.
Example:
The example below has a request to delete all records of old books (with date before year 2000) from the store's default graph
PREFIX dc: <http://purl.org/dc/elements/1.1/>
PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>
DELETE
{ ?book ?p ?v }
WHERE
{ ?book dc:date ?date .
FILTER ( ?date < "2000-01-01T00:00:00-2:00"^^xsd:dateTime )
?book ?p ?v
}The pattern in WHERE is matched against the graph store analogously to SPARQL - Query. The resulting variable bindings are used to instantiate the triple patterns in the DELETE template analogously to CONSTRUCT. The resulting triples are then removed from the graph store. If the pattern matching fails, no changes occur.
Example:
An example to remove all statements about anything with a first name of "Fred" from the graph http://example/addresses. No WHERE clause is present, meaning that the template also serves as the pattern to be matched.
PREFIX foaf: <http://xmlns.com/foaf/0.1/>
WITH <http://example/addresses>
DELETE WHERE { ?person foaf:firstName 'Fred';
?property ?value }
Refer also to the final INSERT example, which demonstrates multiple operations, including a DELETE.
4.1.5 INSERT
[ WITH <uri> ]
INSERT { modify_template [ modify_template ]* }
[ [ USING [NAMED] <uri> ]*
WHERE GroupGraphPattern ]
The INSERT operation is equivalent to the DELETE/INSERT
operation without a specified DELETE section.
If the INSERT template specifies a GRAPH then this will be the graph affected. Otherwise, the operation will be applied to the graph specified in the WITH clause,
if one was specified, or the default graph otherwise. If no WHERE clause is present, then the pattern will be matched in the same way: operating on the GRAPH if one is specified, or else the graph in the WITH clause, or the default graph if no other specifications are used.
The WHERE clause identifies data in existing graphs, and creates bindings to be used by the template. The graphs to apply the GroupGraphPattern to follow the same rules as for DELETE/INSERT.
Example:
This example copies records from one named graph to another named graph based on a pattern.
PREFIX dc: <http://purl.org/dc/elements/1.1/>
PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>
INSERT
{ GRAPH <http://example/bookStore2> { ?book ?p ?v } }
WHERE
{ GRAPH <http://example/bookStore>
{ ?book dc:date ?date .
FILTER ( ?date < "2000-01-01T00:00:00-2:00"^^xsd:dateTime )
?book ?p ?v
} } Example:
An example to copy records from one named graph to another named graph based on a pattern. All the copied objects that are also classified as Physical Objects are then deleted. This demonstrates two operations in a single request, both of which share common PREFIX definitions.
PREFIX dc: <http://purl.org/dc/elements/1.1/>
PREFIX dcmitype: <http://purl.org/dc/dcmitype/>
PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>
INSERT
{ GRAPH <http://example/bookStore2> { ?book ?p ?v } }
WHERE
{ GRAPH <http://example/bookStore>
{ ?book dc:date ?date .
FILTER ( ?date < "2000-01-01T00:00:00-2:00"^^xsd:dateTime )
?book ?p ?v
}
} ;
WITH <http://example/bookStore>
DELETE
{ ?book ?p ?v }
WHERE
{ ?book dc:date ?date ;
dc:type dcmitype:PhysicalObject .
FILTER ( ?date < "2000-01-01T00:00:00-2:00"^^xsd:dateTime )
?book ?p ?v
}
4.1.6 DELETE WHERE
DELETE WHERE { modify_template [ modify_template ]* }
The DELETE WHERE operation is similar to the DELETE/INSERT operation where the triples matched by the WHERE clause will be the triples deleted.
The modify_template is used both as a GroupGraphPattern and as the template for deletion. The form for modify_template is described in DELETE/INSERT. If any modify_template specifies a GRAPH then this will be the graph that that template is matched on, and also the graph from which any matching triples will be removed. Any templates without a GRAPH statement will be applied to the default graph.
Example:
An example to remove all statements about anything with a first name of "Fred" from the default graph.
PREFIX foaf: <http://xmlns.com/foaf/0.1/>
DELETE WHERE { ?person foaf:firstName 'Fred';
?property ?value }
Example:
Find and remove statements naming something "Fred" in the graph http://example.com/names, and also remove all statements about that resource from the graph http://example/addresses.
PREFIX foaf: <http://xmlns.com/foaf/0.1/>
DELETE WHERE {
GRAPH <http://example.com/names> {
?person foaf:firstName 'Fred'
} .
GRAPH <http://example.com/addresses> {
?person ?property ?value
}
}
4.1.7 LOAD
The LOAD operation copies all the triples of a remote graph into the specified graph.
LOAD <documentURI> [ INTO GRAPH <uri> ]
The documentURI specifies the URI of a document such that a store will be able to identify, locate and read the document. Common forms will be URLs with the http or file protocols. Once the document has been read, the resulting triples will be inserted into the destination graph.
If no destination graph URI is provided to load the triples into, then the data will be loaded into the default graph.
4.1.8 CLEAR
The CLEAR operations removes all the triples of the specified graph
or the default graph of the Graph Store if the DEFAULT keyword is used. This operation is not required to remove the empty graph from the Graph Store, but an implementation may decide to do so.
# Remove all triples.
CLEAR GRAPH ( <uri> | DEFAULT )
It has the same effect as:
# Remove all triples.
WITH <uri> DELETE { ?s ?p ?o } WHERE { ?s ?p ?o }but is a clearer expression of emptying a graph. If the GRAPH is not specified then this will clear the default graph.
Note:
For services which form the default graph from the unions of other graphs then this may have far reaching implications.