Status of this
document
This section describes the status of this document at the time of
its publication. Other documents may supersede this document. A list of
current W3C publications and the latest revision of this technical report
can be found in the W3C technical reports
index at http://www.w3.org/TR/.
This is the First Public Working Draft of the "SPARQL 1.1 Protocol for RDF" specification for review by W3C members and
other interested parties.
If you wish to make comments regarding this document, please send them
to public-rdf-dawg-comments@w3.org
(subscribe,
archives)
Implementors should be aware that this specification is not stable.
Implementors who are not taking part in the discussions are likely
to find the specification changing out from under them in incompatible
ways. Vendors interested in implementing this specification before
it eventually reaches the Candidate Recommendation stage should join the
aforementioned mailing lists and take part in the discussions.
Publication as a Working Draft does not imply endorsement by the W3C
Membership. This is a draft document and may be updated, replaced or
obsoleted by other documents at any time. It is inappropriate to cite this
document as other than work in progress.
The publication of this document by the W3C as a W3C Working Draft does
not imply that all of the participants in the W3C SPARQL working group
endorse the contents of the specification. Indeed, for any section of the
specification, one can usually find many members of the working group or of
the W3C as a whole who object strongly to the current text, the existence
of the section at all, or the idea that the working group should even spend
time discussing the concept of that section.
The W3C SPARQL Working Group is
the W3C working group responsible for this specification's progress along
the W3C Recommendation track.
This document was produced by a group operating under the 5 February 2004 W3C
Patent Policy. W3C maintains a public
list of any patent disclosures made in connection with the deliverables
of the group; that page also includes instructions for disclosing a patent.
An individual who has actual knowledge of a patent which the individual
believes contains Essential
Claim(s) must disclose the information in accordance with section
6 of the W3C Patent Policy.
1 Introduction
This document (which refers to itself as "SPARQL 1.1 Protocol for RDF") describes the SPARQL Protocol, a means of conveying SPARQL
queries and updates from clients to query processors. SPARQL Protocol has been designed for compatibility with
the SPARQL 1.1 Query Language for RDF [SPARQL] and with the SPARQL 1.1 Update Language for RDF. SPARQL Protocol is described in
two ways: first, as an abstract interface independent of any concrete realization, implementation, or binding to another
protocol; second, as HTTP bindings of this interface. This document, as well as the associated WSDL and W3C XML Schema
documents, are primarily intended for software developers interested in implementing SPARQL query and update services and clients.
When this document uses the words must,
must not, should, should not, may
and recommended, and the words appear as emphasized text, they must be interpreted as described
in RFC 2119 [RFC2119].
When this document contains excerpts from other documents, including WSDL and XML Schema instances, it uses the following
namespace prefixes and namespace URIs:
| Prefix | Namespace URI |
|---|
st | http://www.w3.org/2005/09/sparql-protocol-types/# |
xs | http://www.w3.org/2001/XMLSchema |
vbr | http://www.w3.org/2005/sparql-results# |
rdf | http://www.w3.org/1999/02/22-rdf-syntax-ns# |
whttp | http://www.w3.org/2006/01/wsdl/http |
wsoap | http://www.w3.org/2006/01/wsdl/soap |
soap | http://www.w3.org/2003/05/soap-envelope |
wsdlx | http://www.w3.org/2005/08/wsdl-extensions |
tns | http://www.w3.org/2005/08/sparql-protocol-query/# |
2 SPARQL Protocol
This set of documents comprises the specification of the SPARQL Protocol:
- SPARQL 1.1 Protocol for RDF
- The current document which normatively specifies the SPARQL 1.1 Protocol for RDF in human-readable language.
- SPARQL 1.1 Protocol for RDF WSDL 2.0 Description
- The normative description of the SPARQL Protocol using WSDL 2.0.
- SPARQL 1.1 Protocol for RDF Types
- The XML Schema document that normatively defines the types used in SPARQL Protocol.
SPARQL Protocol contains one interface, SparqlProtocol, which in turn contains two operations, XXQUERYXX and
XXUPDATEXX. SPARQL
Protocol is described abstractly
with WSDL 2.0 [WSDL2] in terms of a web service that implements its interface, types,
faults, and operations, as well as by HTTP bindings. Note that while this document uses WSDL 2.0 to describe SPARQL
Protocol, there is no obligation on the part of any implementation to use any particular implementation strategy, including the
use of any WSDL library or programming language framework.
2.1 SparqlProtocol Interface
SparqlProtocol is the protocol's only interface. It contains two operations, the first of which is XXQUERYXX, and is used to convey
a SPARQL query string and, optionally,
an RDF dataset description. Secondly the XXUPDATEXX operation is
used to convey a SPARQL update string.
<!-- Abstract SparqlProtocol Interface -->
<interface name="SparqlProtocol" styleDefault="http://www.w3.org/2006/01/wsdl/style/iri">
<!-- the Interface Faults -->
<fault name="MalformedQuery" element="st:malformed-query"/>
<fault name="QueryRequestRefused" element="st:query-request-refused"/>
<!-- the Query Operation -->
<operation name="query" pattern="http://www.w3.org/2006/01/wsdl/in-out">
<documentation>The operation is used to convey queries and their results from clients to services and back
again.</documentation>
<input messageLabel="In" element="st:query-request"/>
<output messageLabel="Out" element="st:query-result"/>
<!-- the interface faults are out faults -->
<outfault ref="tns:MalformedQuery" messageLabel="Out"/>
<outfault ref="tns:QueryRequestRefused" messageLabel="Out"/>
</operation>
<!-- the Update Operation -->
<operation name="update" pattern="http://www.w3.org/2006/01/wsdl/in-out">
<documentation>The operation is used to insert or update RDF data.</documentation>
<input messageLabel="In" element="st:update-request"/>
<output messageLabel="Out" element="st:update-result"/>
<!-- the interface faults are out faults -->
<outfault ref="tns:MalformedRequest" messageLabel="Out"/>
<outfault ref="tns:RequestRefused" messageLabel="Out"/>
</operation>
</interface>
Excerpt 1.0 WSDL 2.0 fragment
2.1.1 XXQUERYXX operation
The XXQUERYXX operation is described as an In-Out
message exchange pattern [WSDL-Adjuncts]. The constraints of an In-Out message exchange pattern are as follows:
This pattern consists of exactly two messages, in order, as
follows:
-
A message:
-
A message:
This pattern uses the rule @@sec@@ Fault
Replaces Message.
2.1.1.1 XXQUERYXX In Message
Abstractly, the contents of the In Message of SparqlProtocol's XXQUERYXX operation is an
instance of an XML Schema complex type, called st:query-request in Excerpt 1.0, composed of two further
parts: one SPARQL query string; and zero or one RDF dataset descriptions. The SPARQL query string,
identified by one XXQUERYXX type, is defined by
[SPARQL] as "a sequence of characters in the language defined by the [SPARQL] grammar, starting with the Query
production". The RDF dataset description is composed of zero or one default RDF graphs — composed by the RDF
merge of the RDF graphs identified by zero or more default-graph-uri types — and by zero or more
named RDF graphs, identified by zero or more named-graph-uri types. These correspond to the
FROM and FROM NAMED keywords in [SPARQL], respectively.
These types are defined in the following XML Schema fragment, from protocol-types.xsd:
<xs:element name="query-request">
<xs:complexType>
<xs:sequence>
<xs:element minOccurs="1" maxOccurs="1" name="query" type="xs:string">
<xs:annotation>
<xs:documentation>query is an xs:string constrained by the language definition,
http://www.w3.org/TR/rdf-sparql-query/#grammar, as "a sequence of characters in
the language defined by the [SPARQL] grammar, starting with the Query production".</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element minOccurs="0" maxOccurs="unbounded" name="default-graph-uri" type="xs:anyURI"/>
<xs:element minOccurs="0" maxOccurs="unbounded" name="named-graph-uri" type="xs:anyURI"/>
</xs:sequence>
</xs:complexType>
</xs:element>Excerpt 1.1 XML Schema fragment
2.1.1.1.1 Specifying an RDF Dataset
The RDF dataset may be specified either in a [SPARQL] query using FROM and FROM NAMED
keywords; or it may be specified in the protocol described in this document; or it may be specified in both the query
string and in the protocol.
2.1.1.1.2 Resolving an Ambiguous RDF Dataset
In the case where both the query and the protocol specify an RDF dataset, but not the identical RDF dataset, the dataset
specified in the protocol must be the RDF dataset consumed by SparqlProtocol's XXQUERYXX operation.
2.1.1.1.4 Determining the Base IRI
The BASE keyword in the query string defines the Base IRI used to resolve relative IRIs
per Uniform Resource Identifier (URI): Generic Syntax
[RFC3986] section 5.1.1, "Base URI Embedded in Content". Section 5.1.2, "Base URI from the Encapsulating
Entity" defines how the Base IRI may come from an encapsulating document, such as a SOAP envelope with an xml:base directive. The
SPARQL Protocol does not dereference query URIs so section 5.1.3 does not apply. Finally, per section 5.1.4, SPARQL Protocol
services must define their own base URI, which may be the service invocation URI.
2.1.1.2 XXQUERYXX Out Message
Abstractly, the contents of the Out Message of SparqlProtocol's XXQUERYXX operation is an
instance of an XML Schema complex type, called query-result in Excerpt 1.2, composed of either:
-
a SPARQL Results Document [SRD] (for SPARQL
Query for RDF query forms SELECT
and ASK); or,
-
an RDF graph [RDF-Concepts] serialized, for example, in the RDF/XML
syntax [RDF-Syntax], or an equivalent RDF graph serialization, for SPARQL Query for RDF query forms
DESCRIBE and
CONSTRUCT).
The query-result type is defined in this W3C XML Schema fragment, from protocol-types.xsd:
<xs:element name="query-result">
<xs:annotation>
<xs:documentation>The type for serializing query results,
either as XML or RDF/XML.</xs:documentation>
</xs:annotation>
<xs:complexType>
<xs:choice>
<xs:element maxOccurs="1" ref="vbr:sparql"/>
<xs:element maxOccurs="1" ref="rdf:RDF"/>
</xs:choice>
</xs:complexType>
</xs:element>Excerpt 1.2 XML Schema fragment
2.1.2 XXUPDATEXX operation
The XXQUERYXX operation is described as an In-Out
message exchange pattern.
2.1.2.1 XXUPDATEXX In Message
Abstractly, the contents of the In Message of SparqlProtocol's XXUPDATEXX operation is an
instance of an XML Schema complex type, called st:update-request, composed of two further
parts: one SPARQL update string; and zero or one RDF dataset descriptions. The SPARQL update string,
identified by one XXUPDATEXX type, is defined by
[SPARQL] as "a sequence of characters in the language defined by the [SPARQLUpdate] grammar, starting with the SPARQLUpdate
production". The RDF dataset description is composed of zero or one default RDF graphs — composed by the RDF
merge of the RDF graphs identified by zero or more default-graph-uri types — and by zero or more
named RDF graphs, identified by zero or more named-graph-uri types. These correspond to the
INTO, FROM and FROM NAMED keywords in [SPARQLUpdate], respectively.
2.1.2.2 XXUPDATEXX Out Message
Abstractly, the contents of the Out Message of SparqlProtocol's XXUPDATEXX operation is an
instance of an XML Schema complex type, called update-result.
Details TBD.
2.1.3 Fault Messages
[WSDL2-Adjuncts] defines several fault propagation rules which specify how operation faults and messages interact. The XXQUERYXX
operation employs the Fault Replaces Message rule:
Any message after the first in the pattern may be replaced with a fault message, which
must have identical direction. The fault message must be delivered to the same target node
as the message it replaces, unless otherwise specified by an extension or binding extension. If there is no path to this
node, the fault must be discarded.
Thus, the XXQUERYXX operation contained in the SparqlProtocol interface may return, in place of
the Out Message, either the MalformedQuery message or the
QueryRequestRefused message, both of which are defined in this XML Schema fragment from protocol-types.xsd:
<xs:element type="xs:string" name="fault-details">
<xs:annotation>
<xs:documentation> This element contains human-readable information about the fault
returned by the SPARQL query processing service.</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element name="malformed-query">
<xs:complexType>
<xs:all><xs:element minOccurs="0" maxOccurs="1" ref="st:fault-details"/></xs:all>
</xs:complexType>
</xs:element>
<xs:element name="query-request-refused">
<xs:complexType>
<xs:all><xs:element minOccurs="0" maxOccurs="1" ref="st:fault-details"/></xs:all>
</xs:complexType>
</xs:element>Excerpt 1.3 XML Schema fragment
2.1.3.1 MalformedQuery
When the value of the XXQUERYXX type is not a legal sequence of characters in the language defined by the SPARQL grammar,
the MalformedQuery or QueryRequestRefused fault message must be returned. According
to the Fault Replaces Message Rule, if a WSDL fault is returned,
including MalformedQuery, an Out Message must not be
returned.
When the MalformedQuery fault message is returned, query processing services must include
explanatory, debugging, or other additional information for human consumption via the
fault-details type defined in Excerpt 1.3.
2.1.3.2 QueryRequestRefused
This WSDL fault message should be returned when a client submits a request that the service refuses to
process. The QueryRequestRefused fault message neither indicates whether the server may or may not process a
subsequent, identical request or requests, nor does it constrain a conformant
SPARQL service from returning other HTTP status codes or HTTP headers as appropriate given the semantics of [HTTP].
When the QueryRequestRefused fault message is returned, query processing services must include
explanatory, debugging, or other additional information intended for human consumption via the
fault-details type defined in Excerpt 1.3.
2.2 HTTP Bindings
The SparqlProtocol interface operations described thus far (XXQUERYXX and XXUPDATE) are abstract operations; they requires protocol
bindings to become invocable operations. This next section of this document describes HTTP
bindings for these operations. A conformant SPARQL Protocol service must support
the SparqlProtocol interface; if a SPARQL Protocol service supports HTTP bindings, it
must support the bindings as described in protocol-query.wsdl. A SPARQL Protocol service may support
other interfaces.
2.2.1 HTTP Bindings for SPARQL Query
[WSDL2-Adjuncts] defines a means of binding abstract interface operations to HTTP. The HTTP bindings for the
XXQUERYXX operation (from protocol-query.wsdl) are as follows:
<!-- the HTTP GET binding for query operation -->
<binding name="queryHttpGet" interface="tns:SparqlProtocol"
type="http://www.w3.org/2006/01/wsdl/http"
whttp:version="1.1">
<fault ref="tns:MalformedQuery" whttp:code="400"/>
<fault ref="tns:QueryRequestRefused" whttp:code="500"/>
<operation ref="tns:query"
wsdlx:safe="true"
whttp:method="GET"
whttp:faultSerialization="*/*"
whttp:inputSerialization="application/x-www-form-urlencoded"
whttp:outputSerialization="application/sparql-results+xml, application/rdf+xml, */*" />
</binding>
<!-- the HTTP POST binding for query operation -->
<binding name="queryHttpPost" interface="tns:SparqlProtocol"
type="http://www.w3.org/2006/01/wsdl/http"
whttp:version="1.1">
<fault ref="tns:MalformedQuery" whttp:code="400"/>
<fault ref="tns:QueryRequestRefused" whttp:code="500"/>
<operation ref="tns:query"
wsdlx:safe="true"
whttp:method="POST"
whttp:faultSerialization="*/*"
whttp:inputSerialization="application/x-www-form-urlencoded, application/xml"
whttp:outputSerialization="application/sparql-results+xml, application/rdf+xml, */*" />
</binding>
There are two HTTP bindings, queryHttpGet and queryHttpPost, both of which are described as bindings of
the SparqlProtocol interface. In each of these bindings, the two faults described
in SparqlProtocol interface, MalformedQuery and QueryRequestRefused, are bound
to HTTP status codes 400 Bad Request and
500 Internal Server Error, respectively [HTTP].
The queryHttpGet binding should be used except in cases where the URL-encoded query exceeds
practical limits, in which case the queryHttpPost binding should be used.
An Informative Note About Serialization Constraints. The output serialization of the
queryHttpGet and queryHttpPost bindings is intentionally under constrained in order to reflect the
variety of serialization types of RDF graphs. The fault serialization of queryHttpGet and
queryHttpPost is also intentionally under constrained. A conformant SPARQL Protocol service can provide alternative WSDL interfaces
and bindings with different constraints.
2.2.1.1 queryHttpGet
This binding of the XXQUERYXX operation uses [HTTP] GET with the following serialization type constraints: the value
of whttp:faultSerialization is */*; second, the value of
whttp:inputSerialization is application/x-www-form-urlencoded with UTF-8 encoding; and,
third, the whttp:outputSerialization is application/sparql-results+xml with UTF-8 encoding,
application/rdf+xml with UTF-8 encoding, and */*.
2.2.1.2 queryHttpPost
This binding of the XXQUERYXX operation uses [HTTP] POST with the following serialization type constraints: the
value of whttp:faultSerialization is */*; second, the value of
whttp:inputSerialization is application/x-www-form-urlencoded with UTF-8 encoding and
application/xml with UTF-8 encoding; and, third, the whttp:outputSerialization is
application/sparql-results+xml with UTF-8 encoding, application/rdf+xml with UTF-8 encoding, and
*/*.
2.2.1.3 HTTP Examples for SPARQL Query
The following abstract HTTP trace examples illustrate invocation of the XXQUERYXX operation under several different
scenarios. These example traces are abstracted from complete HTTP traces in three ways: (1) In each example the string
"EncodedQuery" represents the URL-encoded string equivalent of the SPARQL query given in the first block of each example; (2)
only partial response bodies, containing the query results, are displayed; (3) the URI values of default-graph-uri
and named-graph-uri are also not URL-encoded.
2.2.1.3.1 SELECT with service-supplied RDF dataset
This SPARQL query
PREFIX dc: <http://purl.org/dc/elements/1.1/>
SELECT ?book ?who
WHERE { ?book dc:creator ?who }is conveyed to the SPARQL query
service, http://www.example/sparql/, as illustrated in this
HTTP trace:
GET /sparql/?query=EncodedQuery HTTP/1.1
Host: www.example
User-agent: my-sparql-client/0.1
That query against the service-supplied RDF dataset, executed by
that SPARQL query service, returns the following query result:
HTTP/1.1 200 OK
Date: Fri, 06 May 2005 20:55:12 GMT
Server: Apache/1.3.29 (Unix) PHP/4.3.4 DAV/1.0.3
Connection: close
Content-Type: application/sparql-results+xml
<?xml version="1.0"?>
<sparql xmlns="http://www.w3.org/2005/sparql-results#">
<head>
<variable name="book"/>
<variable name="who"/>
</head>
<results distinct="false" ordered="false">
<result>
<binding name="book"><uri>http://www.example/book/book5</uri></binding>
<binding name="who"><bnode>r29392923r2922</bnode></binding>
</result>
...
</sparql>
2.2.1.3.2 SELECT with simple RDF dataset
This SPARQL query
PREFIX dc: <http://purl.org/dc/elements/1.1/>
SELECT ?book ?who
WHERE { ?book dc:creator ?who }is conveyed to the SPARQL query
service, http://www.other.example/sparql/, as illustrated in
this HTTP trace:
GET /sparql/?query=EncodedQuery&default-graph-uri=http://www.other.example/books HTTP/1.1
Host: www.other.example
User-agent: my-sparql-client/0.1
That query — against the RDF dataset identified by the value
of the default-graph-uri
parameter, http://www.other.example/books — executed
by that SPARQL query service, returns the following query
result:
HTTP/1.1 200 OK
Date: Fri, 06 May 2005 20:55:12 GMT
Server: Apache/1.3.29 (Unix) PHP/4.3.4 DAV/1.0.3
Connection: close
Content-Type: application/sparql-results+xml
<?xml version="1.0"?>
<sparql xmlns="http://www.w3.org/2005/sparql-results#">
<head>
<variable name="book"/>
<variable name="who"/>
</head>
...
</sparql>
2.2.1.3.3 CONSTRUCT with simple RDF
dataset and HTTP content negotiation
This SPARQL query
PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
PREFIX foaf: <http://xmlns.com/foaf/0.1/>
PREFIX myfoaf: <http://www.example/jose/foaf.rdf#>
CONSTRUCT { myfoaf:jose foaf:depiction <http://www.example/jose/jose.jpg>.
myfoaf:jose foaf:schoolHomepage <http://www.edu.example/>.
?s ?p ?o.}
WHERE { ?s ?p ?o. myfoaf:jose foaf:nick "Jo".
FILTER ( ! (?s = myfoaf:kendall && ?p = foaf:knows && ?o = myfoaf:edd )
&& ! ( ?s = myfoaf:julia && ?p = foaf:mbox && ?o = <mailto:julia@mail.example> )
&& ! ( ?s = myfoaf:julia && ?p = rdf:type && ?o = foaf:Person))
}is conveyed to the SPARQL query
service, http://www.example/sparql/, as illustrated in this
HTTP trace:
GET /sparql/?query=EncodedQuery&default-graph-uri=http://www.example/jose-foaf.rdf HTTP/1.1
Host: www.example
User-agent: sparql-client/0.1
Accept: text/turtle, application/rdf+xml
With the response illustrated here:
HTTP/1.1 200 OK
Date: Fri, 06 May 2005 20:55:11 GMT
Server: Apache/1.3.29 (Unix)
Connection: close
Content-Type: text/turtle
@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>.
@prefix foaf: <http://xmlns.com/foaf/0.1/>.
@prefix myfoaf: <http://www.example/jose/foaf.rdf#>.
myfoaf:jose foaf:name "Jose Jimeñez";
foaf:depiction <http://www.example/jose/jose.jpg>;
foaf:nick "Jo";
...Note: registration for the media type text/turtle was started but not completed at the time of this
publication. Please see http://www.w3.org/TeamSubmission/turtle for the final
registered media type for the Turtle language.
2.2.1.3.4 ASK with simple RDF dataset
This SPARQL query
PREFIX dc: <http://purl.org/dc/elements/1.1/>
ASK WHERE { ?book dc:creator "J.K. Rowling"}is conveyed to the SPARQL query
service, http://www.example/sparql/, as illustrated in this
HTTP trace:
GET /sparql/?query=EncodedQuery&default-graph-uri=http://www.example/books HTTP/1.1
Host: www.example
User-agent: sparql-client/0.1
With the response illustrated here:
HTTP/1.1 200 OK
Date: Fri, 06 May 2005 20:48:25 GMT
Server: Apache/1.3.29 (Unix) PHP/4.3.4 DAV/1.0.3
Connection: close
Content-Type: application/sparql-results+xml
<?xml version="1.0"?>
<sparql xmlns="http://www.w3.org/2005/sparql-results#">
<head></head>
<boolean>true</boolean>
</sparql>
2.2.1.3.5 DESCRIBE with simple RDF dataset
This SPARQL query
PREFIX books: <http://www.example/book/>
DESCRIBE books:book6
is conveyed to the SPARQL query
service, http://www.example/sparql/, as illustrated here:
GET /sparql/?query=EncodedQuery&default-graph-uri=http://www.example/books HTTP/1.1
Host: www.example
User-agent: sparql-client/0.1
With the response illustrated here:
HTTP/1.1 200 OK
Date: Wed, 03 Aug 2005 12:48:25 GMT
Server: Apache/1.3.29 (Unix) PHP/4.3.4 DAV/1.0.3
Connection: close
Content-Type: application/rdf+xml
<?xml version="1.0"?>
<rdf:RDF ...
<rdf:Description rdf:about="http://www.example/book/book6">
<dc:title>Example Book #6 </dc:title>
</rdf:Description>
</rdf:RDF>
2.2.1.3.6 SELECT with complex RDF dataset
This SPARQL query
PREFIX foaf: <http://xmlns.com/foaf/0.1/>
PREFIX dc: <http://purl.org/dc/elements/1.1/>
SELECT ?who ?g ?mbox
WHERE { ?g dc:publisher ?who .
GRAPH ?g { ?x foaf:mbox ?mbox }
}is conveyed to the SPARQL query service, http://www.example/sparql/,
as illustrated here (with line breaks for legibility):
GET /sparql/?query=EncodedQuery&default-graph-uri=http://www.example/publishers
&default-graph-uri=http://www.example/morepublishers&named-graph-uri=http://your.example/foaf-alice
&named-graph-uri=http://www.example/foaf-bob&named-graph-uri=http://www.example/foaf-susan
&named-graph-uri=http://this.example/john/foaf
Host: www.example
User-agent: sparql-client/0.1
With the response illustrated here:
HTTP/1.1 200 OK
Date: Wed, 03 Aug 2005 12:48:25 GMT
Server: Apache/1.3.29 (Unix) PHP/4.3.4 DAV/1.0.3
Connection: close
Content-Type: application/sparql-results+xml
<?xml version="1.0"?>
<sparql xmlns="http://www.w3.org/2005/sparql-results#">
<head>
<variable name="who"/>
<variable name="g"/>
<variable name="mbox"/>
</head>
...
</sparql>
2.2.1.3.7 SELECT with query-only RDF dataset
This SPARQL query
PREFIX foaf: <http://xmlns.com/foaf/0.1/>
PREFIX dc: <http://purl.org/dc/elements/1.1/>
SELECT ?who ?g ?mbox
FROM <http://www.example/publishers>
FROM NAMED <http://www.example/alice>
FROM NAMED <http://www.example/bob>
WHERE { ?g dc:publisher ?who .
GRAPH ?g { ?x foaf:mbox ?mbox }
}is conveyed to the SPARQL query service, http://www.example/sparql/, as illustrated in this
HTTP trace:
GET /sparql/?query=EncodedQuery HTTP/1.1
Host: www.example
User-agent: sparql-client/0.1
With the response illustrated here:
HTTP/1.1 200 OK
Date: Wed, 03 Aug 2005 12:48:25 GMT
Server: Apache/1.3.29 (Unix) PHP/4.3.4 DAV/1.0.3
Connection: close
Content-Type: application/sparql-results+xml
<?xml version="1.0"?>
<sparql xmlns="http://www.w3.org/2005/sparql-results#">
...
</sparql>
2.2.1.3.8 SELECT with ambiguous RDF dataset
This SPARQL query
PREFIX foaf: <http://xmlns.com/foaf/0.1/>
PREFIX dc: <http://purl.org/dc/elements/1.1/>
SELECT ?who ?g ?mbox
FROM <http://www.example/publishers>
FROM NAMED <http://www.example/john>
FROM NAMED <http://www.example/susan>
WHERE { ?g dc:publisher ?who .
GRAPH ?g { ?x foaf:mbox ?mbox }
}is conveyed to the SPARQL query
service, http://www.example/sparql/, as illustrated in this
HTTP trace:
GET /sparql/?query=EncodedQuery&default-graph-uri=http://www.example/morepublishers
&named-graph-uri=http://www.example/bob&named-graph-uri=http://www.example/alice HTTP/1.1
Host: www.example
User-agent: sparql-client/0.1
This protocol operation contains an ambiguous RDF dataset: the dataset specified in the query is different than the one
specified in the protocol (by way of default-graph-uri and named-graph-uri parameters). A
conformant SPARQL Protocol service must resolve this ambiguity by executing the query against the RDF dataset specified in
the protocol:
HTTP/1.1 200 OK
Date: Wed, 03 Aug 2005 12:48:25 GMT
Server: Apache/1.3.29 (Unix) PHP/4.3.4 DAV/1.0.3
Connection: close
Content-Type: application/sparql-results+xml
<?xml version="1.0"?>
<sparql xmlns="http://www.w3.org/2005/sparql-results#">
<head>
<variable name="who"/>
<variable name="g"/>
<variable name="mbox"/>
</head>
<results ordered="false" distinct="false">
<result>
<binding name="who">
<literal>Bob Hacker</literal>
</binding>
<binding name="g">
<uri>http://www.example/bob</uri>
</binding>
<binding name="mbox">
<uri>mailto:bob@oldcorp.example</uri>
</binding>
</result>
<result>
<binding name="who">
<literal>Alice Hacker</literal>
</binding>
<binding name="g">
<uri>http://www.example/alice</uri>
</binding>
<binding name="mbox">
<uri>mailto:alice@work.example</uri>
</binding>
</result>
</results>
</sparql>
2.2.1.3.9 SELECT with malformed query fault
This syntactically invalid SPARQL query
2.2.1.3.10 SELECT with query request refused fault
This SPARQL query
PREFIX bio: <http://bio.example/schema/#>
SELECT ?valence
FROM <http://another.example/protein-db.rdf>
WHERE { ?x bio:protein ?valence }
ORDER BY ?valenceis conveyed to the SPARQL query
service, http://www.example/sparql/, as illustrated in this
HTTP trace:
GET /sparql/?query=EncodedQuery&default-graph-uri=http://another.example/protein-db.rdf HTTP/1.1
Host: www.example
User-agent: sparql-client/0.1
With the response — the QueryRequestRefused
fault replacing the Out Message, as per @@sec@@
SparqlProtocol — illustrated here:
HTTP/1.1 500 Internal Server Error
Date: Wed, 03 Aug 2005 12:48:25 GMT
Server: Apache/1.3.29 (Unix) PHP/4.3.4 DAV/1.0.3
Connection: close
Content-Type: text/html; charset=UTF-8
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
<html>
<head>
<title>SPARQL Processing Service: Query Request Refused</title>
</head>
<body>
<p> Query Request Refused: your request could not be processed because
<code>http://another.example/protein-db.rdf</code> could not be retrieved within
the time alloted.</p>
</body>
</html>
2.2.1.3.11 Very long SELECT query using POST binding
Some SPARQL queries, perhaps machine generated, may be longer than
can be reliably conveyed by way of the HTTP GET binding described in
@@sec@@ HTTP Bindings. In those cases
the POST binding described in @@sec@@ may be used. This SPARQL query
PREFIX : <http://www.w3.org/2002/12/cal/icaltzd#>
PREFIX Chi: <http://www.w3.org/2002/12/cal/test/Chiefs.ics#>
PREFIX New: <http://www.w3.org/2002/12/cal/tzd/America/New_York#>
PREFIX XML: <http://www.w3.org/2001/XMLSchema#>
SELECT ?summary
WHERE {
{
Chi:D603E2AC-C1C9-11D6-9446-003065F198AC a :Vevent;
:dtend "2002-09-08T16:00:00"^^New:tz;
:dtstamp "2002-09-06T03:09:27Z"^^XML:dateTime;
:dtstart "2002-09-08T13:00:00"^^New:tz;
:summary ?summary;
:uid "D603E2AC-C1C9-11D6-9446-003065F198AC" .
}
UNION
{
Chi:D603E90B-C1C9-11D6-9446-003065F198AC a :Vevent;
:dtend "2002-09-15T16:00:00"^^New:tz;
:dtstamp "2002-09-06T03:10:19Z"^^XML:dateTime;
:dtstart "2002-09-15T13:00:00"^^New:tz;
:summary ?summary;
:uid "D603E90B-C1C9-11D6-9446-003065F198AC" .
}
UNION
{
Chi:D603ED6E-C1C9-11D6-9446-003065F198AC a :Vevent;
:dtend "2002-09-22T16:00:00"^^New:tz;
:dtstamp "2002-09-06T03:11:05Z"^^XML:dateTime;
:dtstart "2002-09-22T13:00:00"^^New:tz;
:summary ?summary;
:uid "D603ED6E-C1C9-11D6-9446-003065F198AC" .
}
UNION
{
Chi:D603F18C-C1C9-11D6-9446-003065F198AC a :Vevent;
:dtend "2002-09-29T16:00:00"^^New:tz;
:dtstamp "2002-09-06T03:15:46Z"^^XML:dateTime;
:dtstart "2002-09-29T13:00:00"^^New:tz;
:summary ?summary;
:uid "D603F18C-C1C9-11D6-9446-003065F198AC" .
}
UNION
{
Chi:D603F5B7-C1C9-11D6-9446-003065F198AC a :Vevent;
:dtend "2002-11-04"^^XML:date;
:dtstamp "2002-09-06T03:12:53Z"^^XML:dateTime;
:dtstart "2002-11-03"^^XML:date;
:summary ?summary;
:uid "D603F5B7-C1C9-11D6-9446-003065F198AC" .
}
UNION
{
Chi:D603F9D7-C1C9-11D6-9446-003065F198AC a :Vevent;
:dtend "2002-11-10T20:15:00"^^New:tz;
:dtstamp "2002-09-06T03:14:12Z"^^XML:dateTime;
:dtstart "2002-11-10T17:15:00"^^New:tz;
:summary ?summary;
:uid "D603F9D7-C1C9-11D6-9446-003065F198AC" .
}
UNION
{
Chi:D604022C-C1C9-11D6-9446-003065F198AC a :Vevent;
:dtend "2002-11-17T17:00:00"^^New:tz;
:dtstamp "2002-09-06T03:14:51Z"^^XML:dateTime;
:dtstart "2002-11-17T14:00:00"^^New:tz;
:summary ?summary;
:uid "D604022C-C1C9-11D6-9446-003065F198AC" .
}
UNION
{
Chi:D604065C-C1C9-11D6-9446-003065F198AC a :Vevent;
:dtend "2002-10-06T19:05:00"^^New:tz;
:dtstamp "2002-09-06T03:16:54Z"^^XML:dateTime;
:dtstart "2002-10-06T16:05:00"^^New:tz;
:summary ?summary;
:uid "D604065C-C1C9-11D6-9446-003065F198AC" .
}
UNION
{
Chi:D6040A7E-C1C9-11D6-9446-003065F198AC a :Vevent;
:dtend "2002-10-13T19:15:00"^^New:tz;
:dtstamp "2002-09-06T03:17:51Z"^^XML:dateTime;
:dtstart "2002-10-13T16:15:00"^^New:tz;
:summary ?summary;
:uid "D6040A7E-C1C9-11D6-9446-003065F198AC" .
}
UNION
{
Chi:D6040E96-C1C9-11D6-9446-003065F198AC a :Vevent;
:dtend "2002-10-20T16:00:00"^^New:tz;
:dtstamp "2002-09-06T03:18:32Z"^^XML:dateTime;
:dtstart "2002-10-20T13:00:00"^^New:tz;
:summary ?summary;
:uid "D6040E96-C1C9-11D6-9446-003065F198AC" .
}
UNION
{
Chi:D6041270-C1C9-11D6-9446-003065F198AC a :Vevent;
:dtend "2002-10-27T17:00:00"^^New:tz;
:dtstamp "2002-09-06T03:19:15Z"^^XML:dateTime;
:dtstart "2002-10-27T14:00:00"^^New:tz;
:summary ?summary;
:uid "D6041270-C1C9-11D6-9446-003065F198AC" .
}
UNION
{
Chi:D6041673-C1C9-11D6-9446-003065F198AC a :Vevent;
:dtend "2002-11-24T20:05:00"^^New:tz;
:dtstamp "2002-09-06T03:22:09Z"^^XML:dateTime;
:dtstart "2002-11-24T17:05:00"^^New:tz;
:summary ?summary;
:uid "D6041673-C1C9-11D6-9446-003065F198AC" .
}
UNION
{
Chi:D6041A73-C1C9-11D6-9446-003065F198AC a :Vevent;
:dtend "2002-12-01T17:00:00"^^New:tz;
:dtstamp "2002-09-06T03:22:52Z"^^XML:dateTime;
:dtstart "2002-12-01T14:00:00"^^New:tz;
:summary ?summary;
:uid "D6041A73-C1C9-11D6-9446-003065F198AC" .
}
UNION
{
Chi:D60421EF-C1C9-11D6-9446-003065F198AC a :Vevent;
:dtend "2002-12-08T17:00:00"^^New:tz;
:dtstamp "2002-09-06T03:24:04Z"^^XML:dateTime;
:dtstart "2002-12-08T14:00:00"^^New:tz;
:summary ?summary;
:uid "D60421EF-C1C9-11D6-9446-003065F198AC" .
}
UNION
{
Chi:D6042660-C1C9-11D6-9446-003065F198AC a :Vevent;
:dtend "2002-12-15T20:05:00"^^New:tz;
:dtstamp "2002-09-06T03:25:03Z"^^XML:dateTime;
:dtstart "2002-12-15T17:05:00"^^New:tz;
:summary ?summary;
:uid "D6042660-C1C9-11D6-9446-003065F198AC" .
}
UNION
{
Chi:D6042A93-C1C9-11D6-9446-003065F198AC a :Vevent;
:dtend "2002-12-22T17:00:00"^^New:tz;
:dtstamp "2002-09-06T03:25:47Z"^^XML:dateTime;
:dtstart "2002-12-22T14:00:00"^^New:tz;
:summary ?summary;
:uid "D6042A93-C1C9-11D6-9446-003065F198AC" .
}
UNION
{
Chi:D6042EDF-C1C9-11D6-9446-003065F198AC a :Vevent;
:dtend "2002-12-28T21:00:00"^^New:tz;
:dtstamp "2002-09-06T03:26:51Z"^^XML:dateTime;
:dtstart "2002-12-28T18:00:00"^^New:tz;
:summary ?summary;
:uid "D6042EDF-C1C9-11D6-9446-003065F198AC" .
}
}is conveyed to the SPARQL query
service, http://www.example/sparql/, as illustrated in this
HTTP trace:
POST /sparql/ HTTP/1.1
Host: www.example
User-agent: sparql-client/0.1
Content-Type: application/x-www-form-urlencoded
Content-Length: 9461
query=EncodedQuery&default-graph-uri=http://another.example/calendar.rdf
With the response illustrated here:
HTTP/1.1 200 OK
Date: Wed, 03 Aug 2005 12:48:25 GMT
Server: Apache/1.3.29 (Unix) PHP/4.3.4 DAV/1.0.3
Connection: close
Content-Type: application/sparql-results+xml
<?xml version="1.0"?>
<sparql xmlns="http://www.w3.org/2005/sparql-results#">
<head>
<variable name="summary"/>
</head>
<results ordered="false" distinct="false">
<result>
<binding name="summary">
<literal>Chiefs vs. Cleveland @ Cleveland Stadium</literal>
</binding>
</result>
<result>
<binding name="summary">
<literal>Chiefs vs. Jacksonville @ Arrowhead Stadium</literal>
</binding>
</result>
<result>
<binding name="summary">
<literal>Chiefs vs. New England @ Gillette Stadium</literal>
</binding>
</result>
...
<result>
<binding name="summary">
<literal>Chiefs vs. Oakland @ Network Associates Coliseum</literal>
</binding>
</result>
</results>
</sparql>
2.2.1.3.12 SELECT with internationalization
SPARQL queries may include internationalized characters or character sets. This SPARQL query
PREFIX foaf: <http://xmlns.com/foaf/0.1/>
PREFIX 食: <http://www.w3.org/2001/sw/DataAccess/tests/data/i18n/kanji.ttl#>
SELECT ?name ?food
WHERE { [ foaf:name ?name ; 食:食べる ?food ] . }is conveyed to the SPARQL query service, http://www.example/sparql/, as illustrated in this HTTP trace:
GET /sparql/?query=EncodedQuery
Host: www.example
User-agent: sparql-client/0.1
HTTP/1.1 200 OK
Date: Wed, 03 Aug 2005 12:48:25 GMT
Server: Apache/1.3.29 (Unix)
Connection: close
Content-Type: application/sparql-results+xml
<?xml version="1.0"?>
<sparql xmlns="http://www.w3.org/2005/sparql-results#">
...
</sparql>
| Editorial note: TODO @@ | 2009-Oct-20 |
| Put in internationalized results |
2.2.1.3.13 SELECT with queryHttpPost binding and XML input
| Editorial note | |
| The current SPARQL Working Group does not intend to standardize an XML serialization of SPARQL queries at this point in time, and this section may be removed from the specification. |
In some future version SPARQL queries could be serialized as XML and conveyed to
a SPARQL query service by way of HTTP POST. This SPARQL query
<?xml version="1.0"?>
<rdf-query xmlns="http://example.org/SparqlX/">
<select><variable name="book"/><variable name="who"/></select>
<query-pattern>
<triple-pattern>
<subject><variable name="book"/></subject>
<predicate><uri>http://purl.org/dc/elements/1.1/creator</uri></predicate>
<object><variable name="who"/></object>
</triple-pattern>
</query-pattern>
</rdf-query>
is conveyed to the SPARQL query
service, http://www.example/sparql/, as illustrated in this
HTTP trace:
POST /sparql/ HTTP/1.1
Host: www.example
User-agent: my-sparql-client/0.1
Content-type: application/xml
<?xml version="1.0"?>
<rdf-query xmlns="http://example.org/SparqlX/">
<select><variable name="book"/><variable name="who"/></select>
<query-pattern>
<triple-pattern>
<subject><variable name="book"/></subject>
<predicate><uri>http://purl.org/dc/elements/1.1/creator</uri></predicate>
<object><variable name="who"/></object>
</triple-pattern>
</query-pattern>
</rdf-query>
That query against the service-supplied RDF dataset, executed by
that SPARQL query service, returns the following query result:
HTTP/1.1 200 OK
Date: Fri, 06 May 2005 20:55:12 GMT
Server: Apache/1.3.29 (Unix) PHP/4.3.4 DAV/1.0.3
Connection: close
Content-Type: application/sparql-results+xml
<?xml version="1.0"?>
<sparql xmlns="http://www.w3.org/2005/sparql-results#">
<head>
<variable name="book"/>
<variable name="who"/>
</head>
<results distinct="false" ordered="false">
<result>
<binding name="book"><uri>http://www.example/book/book5</uri></binding>
<binding name="who"><bnode>r29392923r2922</bnode></binding>
</result>
...
</sparql>
2.2.2 HTTP Bindings for SPARQL Update
2.2.2.1 HTTP Examples for SPARQL Update
| Editorial note | |
| This is a placeholder for example HTTP interactions for sending SPARQL 1.1 Update commands via HTTP POST. |
@@
2.3 Other Bindings
[WSDL2-Adjuncts] defines a means of binding abstract interface
operations to to other transports such as SOAP. Any implementation of this specification is at liberty to provide alternative
bindings.
3 Policy Considerations
3.1 Security
| Editorial note | |
| The editors note that security concerns for issuing SPARQL 1.1 Update commands over the protocol should be addressed. |
There are at least two possible sources of denial-of-service attacks against SPARQL protocol services. First, under-constrained
queries can result in very large numbers of results, which may require large expenditures of computing resources to process,
assemble, or return. Another possible source are queries containing very complex — either because of resource size, the number
of resources to be retrieved, or a combination of size and number — RDF dataset descriptions, which the service may be unable
to assemble without significant expenditure of resources, including bandwidth, CPU, or secondary storage. In some cases such
expenditures may effectively constitute a denial-of-service attack. A SPARQL protocol service may place
restrictions on the resources that it retrieves or on the rate at which external resources are retrieved. There may be other sources
of denial-of-service attacks against SPARQL query processing services.
Since a SPARQL protocol service may make HTTP requests of other origin servers on behalf of its clients, it may be used as a
vector of attacks against other sites or services. Thus, SPARQL protocol services may effectively act as proxies for third-party
clients. Such services may place restrictions on the resources that they retrieve or on the rate at which external
resources can be retrieved. SPARQL protocol services may log client requests in such a way as to facilitate tracing
them with regard to third-party origin servers or services.
SPARQL protocol services may choose to detect these and other costly, or otherwise unsafe, queries, impose time
or memory limits on queries, or impose other restrictions to reduce the service's (and other service's) vulnerability to
denial-of-service attacks. They also may refuse to process such query requests.
Different IRIs may have the same appearance. Characters in different scripts may look similar (a Cyrillic "о" may appear similar
to a Latin "o"). A character followed by combining characters may have the same visual representation as another character (LATIN
SMALL LETTER E followed by COMBINING ACUTE ACCENT has the same visual representation as LATIN SMALL LETTER E WITH ACUTE). Users of
SPARQL must take care to construct queries with IRIs that match the IRIs in the data. Further information about matching of similar
characters can be found in Unicode Security Considerations [UNISEC]
and Internationalized Resource Identifiers (IRIs) [RFC3987] Section 8.
4 Conformance
The status of the parts of SPARQL 1.1 Protocol for RDF (this document) is as follows:
- Section 1 Introduction: normative
- Section 2 SPARQL Protocol: normative, except for the paragraph (in 2.2 HTTP Bindings) labeled "An Informative Note About Serialization Constraints", which is informative.
- Subsection 2.2.1 HTTP Examples: informative
- Section 3: Policy Considerations: normative
- Section 4: Conformance: normative
- Section 5.1: Normative References: normative
- Section 5.2: Informative References: informative
- Section 6: Acknowledgments: informative
Further, both protocol-query.wsdl and protocol-types.xsd are normative.
A conformant SPARQL Protocol service:
- must implement one or more operations of the
SparqlProtocol interface; - may implement HTTP bindings of the XXQUERYXX operation of the
SparqlProtocol interface; - may implement HTTP bindings of the XXUPDATEXX operation of the
SparqlProtocol interface; - must implement HTTP bindings of XXQUERYXX and XXUPDATEXX in the way described in this document ("SPARQL 1.1 Protocol for RDF"), in protocol-query.wsdl, and protocol-types.xsd;
- may implement other interfaces, bindings of the operations of those interfaces, or bindings of the XXQUERYXX and XXUPDATEXX operations other than the normative HTTP bindings described by SPARQL 1.1 Protocol for RDF; and
- must be consistent with the normative constraints (indicated by [RFC 2119] keywords) described in 3. Policy Considerations.
5 Changes Since Previous Recommendation
This specification extends and updates the SPARQL Protocol for RDF of January, 2008. The significant changes are:
- Change the name of the one protocol interface from SparqlQuery to SparqlProtocol
- Define an Update operation for issuing SPARQL Update commands
- Define HTTP bindings for the Update operation
- Removed the section on SOAP bindings, and referred to other WSDL bindings in general
- Updated conformance criteria to align with the removal of the normative SOAP bindings