Copyright © 2003 W3C ® ( MIT , ERCIM , Keio ), All Rights Reserved. W3C liability , trademark , document use and software licensing rules apply.
The Resource Description Framework ( RDF ) is a general-purpose language for representing information in the Web.
This document defines an XML syntax for RDF called RDF/XML in terms of deleted text: XML Namespaces in XML , the XML Information Set and XML Base . The formal grammar for the syntax is annotated with actions generating triples of the <a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-rdf-graph"> RDF Graph graph as defined in <a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/"> RDF Concepts and Abstract Syntax . This is done The triples are written using the <a href="http://www.w3.org/TR/2003/WD-rdf-testcases-20030123/#ntriples"> N-Triples RDF Graph graph serializing format which enables more precise recording of the mapping in a machine processable form. The mappings are recorded as tests cases, gathered and published in <a href="http://www.w3.org/TR/2003/WD-rdf-testcases-20030123/"> RDF Test Cases .
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 a W3C Last Call Working Draft of the RDF Core Working Group and has been produced as part of the W3C Semantic Web Activity ( Activity Statement ).
In
this
version
rdf:RDF
was
made
optional
when
it
contains
a
single
node
element,
the
Unicode
Normal
Form
C
(NFC)
checks
on
literals
were
modified
to
be
optional
and
other
minor
fixes
were
made.
Detailed
changes
from
the
previous
23
January
2003
last
call
working
draft
are
described
in
the
Appendix
B
.
Changes
since
the
previous
05
September
2003
working
draft
are
given
in
Appendix
C
.
This document is in the Last Call review period, which ends on 21 February 07 November 2003. This document has been endorsed by the RDF Core Working Group. </p> <p> This document revises RDF/XML from the original definition Last Call publication consolidates changes and editorial improvements undertaken in response to feedback received during the <a href="http://www.w3.org/TR/1999/REC-rdf-syntax-19990222/#grammar"> grammar section previous Last Call publication of <a href="http://www.w3.org/TR/1999/REC-rdf-syntax-19990222/"> RDF Model & Syntax </a> <a href="#ref-rdfms"> [RDF-MS] the RDFCore specifications which began on 23 January 2003. A list of the Last Call issues W3C Recommendation after decisions made addressed by the deleted text: <a href="http://www.w3.org/2001/sw/RDFCore/"> RDF Core Working Group deleted text: </a>. In particular, the <a href="#section-Infoset-Grammar"> formal grammar </a> is now in terms of the <a href="http://www.w3.org/TR/2001/REC-xml-infoset-20011024/"> XML Information Set </a> <a href="#ref-xml-infoset"> [INFOSET] </a>. </p> <p> In this revision, new support was added for <a href="http://www.w3.org/TR/2001/REC-xmlbase-20010627/"> XML Base </a> <a href="#ref-xml-base"> [XML-BASE] </a>, RDF Datatyping with <a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-typed-literal"> Typed Literals </a> using <code> rdf:datatype </code>, <code> rdf:nodeID </code> to allow referencing of <a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-blank-node"> Blank Nodes </a> and <code> rdf:parseType="Collection" </code> for expressing a collection of <a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-node"> Nodes </a>. The revision removed <code> rdf:aboutEach </code> and <code> rdf:aboutEachPrefix </code> from also available. This document has been endorsed by the deleted text: syntax (see RDF Core issues <a href="http://www.w3.org/2000/03/rdf-tracking/#rdfms-aboutEach-on-object"> rdfms-aboutEach-on-object </a> and <a href="http://www.w3.org/2000/03/rdf-tracking/#rdfms-abouteachprefix"> rdfms-abouteachprefix </a> ). </p> <p> The detailed changes from the previous <a href="http://www.w3.org/TR/2002/WD-rdf-syntax-grammar-20021108/"> 8 November 2002 working draft </a> are described in the <a href="#section-Changes"> Changes section </a>. Working Group.
This document is being released for review by W3C Members and other interested parties to encourage feedback and comments, especially with regard to how the changes made affect existing implementations and content.
In conformance with W3C policy requirements, known patent and IPR constraints associated with this Working Draft are detailed on the RDF Core Working Group Patent Disclosure page.
Comments on this document are invited and should be sent to the public mailing list www-rdf-comments@w3.org . An archive of comments is available at http://lists.w3.org/Archives/Public/www-rdf-comments/ .
This is Publication as a deleted text: public W3C Last Call Working Draft for review does not imply endorsement by the W3C Members and other interested parties. Membership. This deleted text: section describes the status of this document at the time of its publication. It is a draft document and may be updated, replaced, replaced or obsoleted by other documents at any time. It is inappropriate to deleted text: use W3C Working Drafts as reference material or to cite this document as other than "work work in progress". progress. A list of current W3C Recommendations and other technical documents can be found at <a href="/TR/"> http://www.w3.org/TR/ </a>. http://www.w3.org/TR/.
1
Introduction
2
An
XML
syntax
Syntax
for
RDF
2.1
Introduction
2.2
Node
Elements
and
Property
Elements
2.3
Multiple
Property
Elements
2.4
Empty
Property
Elements
2.5
Property
Attributes
2.6
Completing
the
Document
-
Document:
Document
Element
and
XML
Declaration
2.7
Languages
-
Languages:
xml:lang
2.8
XML
Literals
-
Literals:
rdf:parseType="Literal"
2.9
Typed
Literals
-
Literals:
rdf:datatype
2.10
Identifying
Blank
Nodes
-
Nodes:
rdf:nodeID
2.11
Omitting
Blank
Nodes
-
Nodes:
rdf:parseType="Resource"
2.12
Omitting
Nodes
-
Nodes:
Property
Attributes
on
an
empty
Property
Element
2.13
Typed
Node
Elements
2.14
Abbreviating
URI
References
-
References:
rdf:ID
and
xml:base
2.15
Container
membership
property
elements
-
Membership
Property
Elements:
rdf:li
and
rdf:_
n
2.16
Collections
-
Collections:
rdf:parseType="Collection"
2.17
Reifying
Statements
-
<code>
rdf:bagID
</code>
and
Statements:
rdf:ID
deleted text:
2.18
<a href="#section-Syntax-more">
More
Information
</a>
<br />
3
Terminology
4
RDF
MIME
type,
file
extension
Type,
File
Extension
and
Macintosh
file
type
File
Type
5
Global
Issues
5.1
The
RDF
Namespace
and
Vocabulary
5.2
Identifiers
5.3
Resolving
URIs
5.4
Constraints
5.5
Conformance
6
Syntax
Data
Model
6.1
Events
6.2
Information
Set
Mapping
6.3
Grammar
Notation
7
RDF/XML
Grammar
7.1
Grammar
Summary
7.2
Grammar
Productions
7.3
Reification
Rules
7.4
List
Expansion
Rules
deleted text:
7.5
<a href="#section-Bag-Expand">
Bag
Expansion
Rules
</a>
<br />
8
Serializing
an
RDF
Graph
to
RDF/XML
9
Using
RDF/XML
in
with
HTML
and
XHTML
10
Using
RDF/XML
with
SVG
11
Acknowledgments
11
12
References
A
Syntax
Schemas
(Informative)
A.1
RELAX NG
Compact
Syntax
Schema
(Informative)
B
Changes
Revisions
between
Drafts
23
January
and
05
September
2003
(Informative)
C
Revisions
since
Working
Draft
05
September
2003
(Informative)
This document defines the XML [XML] syntax for RDF Graphs graphs which was originally defined in the RDF Model & Syntax [RDF-MS] W3C Recommendation. Subsequent implementations of this syntax and comparison of the resulting RDF Graphs graphs have shown that there was ambiguity - — implementations generated different graphs and certain syntax forms were not widely implemented.
deleted text: The <a href="http://www.w3.org/2001/sw/RDFCore/"> RDF Core Working Group </a> is <a href="http://www.w3.org/2001/sw/RDFCoreWGCharter"> chartered </a> to respond to the need for a number of fixes, clarifications and improvements to the specification of RDF's abstract graph and XML syntax as recorded in the <a href="http://www.w3.org/2000/03/rdf-tracking/"> RDF Core Working Group issues list </a>. The Working Group invites feedback from the developer community on the effects of its proposals on existing implementations and documents. </p> <p> This document revises the original RDF/XML grammar in terms of XML Information Set [INFOSET] Information Items information items which moves away from the rather low-level details of XML, such as particular forms of empty elements. This allows the grammar to be more precisely recorded and the mapping from the XML syntax to the RDF Graph more clearly shown. The mapping to the RDF Graph graph is done by emitting statements in the form defined in the <a href="http://www.w3.org/TR/2003/WD-rdf-testcases-20030123/#ntriples"> N-Triples section of <a href="http://www.w3.org/TR/2003/WD-rdf-testcases-20030123/"> RDF Test Cases [RDF-TESTS] deleted text: Working Draft which creates an RDF Graph, graph, that has semantics defined by <a href="http://www.w3.org/TR/2003/WD-rdf-mt-20030123/"> RDF Semantics [RDF-SEMANTICS] </a> Working Draft. .
The complete specification of RDF consists of a number of documents:
For a longer introduction to the RDF/XML syntax with a historical perspective, see RDF: Understanding the Striped RDF/XML Syntax [STRIPEDRDF] .
This section introduces the RDF/XML syntax, describes how it encodes RDF Graphs graphs and explains this with examples. If there is any conflict between this informal description and the formal description of the syntax and grammar in sections 6 Syntax Data Model and 7 RDF/XML Grammar , the latter two sections take precedence.
The <a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/"> RDF Concepts and Abstract Syntax [RDF-CONCEPTS] deleted text: working draft defines the <a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#section-data-model"> RDF Graph data model (Section 3.1) and the <a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-rdf-graph"> RDF Graph abstract syntax (Section 6.2). 6). Along with the <a href="http://www.w3.org/TR/2003/WD-rdf-mt-20030123/"> RDF Semantics [RDF-SEMANTICS] deleted text: working draft this provides an abstract syntax with a formal semantics for it. The RDF Graph graph has <a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-node"> Nodes nodes and labeled directed Arcs arcs that link pairs of Nodes nodes and this is represented as a set of <a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-rdf-triple"> RDF triples where each triple contains a Subject Node subject node , Property Arc predicate and Object Node object node . Nodes are <a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-URI-reference"> RDF URI References references , <a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-literal"> RDF Literals literals or are <a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-blank-node"> Blank Nodes blank nodes . Blank Nodes nodes may be given a document-local, non- <a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-URI-reference"> RDF URI References references identifier called a <a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-blank-node-id"> Blank Node Identifier blank node identifier . <em> Arcs </em> Predicates are labeled with <a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-URI-reference"> RDF URI References </a>. The property arc references and can be interpreted as either a relationship between the two nodes or as defining an attribute value (object node) for some subject node.
In order to encode the graph in XML, the nodes and arcs predicates have to be represented by in XML terms — element names, attribute names, element content contents and attribute content. values. RDF/XML uses XML QNames as defined in Namespaces in XML [XML-NS] to represent <a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-URI-reference"> RDF URI References references . The <a href="http://www.w3.org/TR/1999/REC-xml-names-19990114/#NT-Prefix"> All QNames have a namespace prefix name part of all QNames which is deleted text: associated with a URI Reference as defined in <a href="http://www.w3.org/TR/1999/REC-xml-names-19990114/"> XML Namespaces </a> <a href="#ref-namespaces"> [XML-NS] reference and a short local name . In addition, QNames can either have a short prefix or be declared with the default namespace declaration and have none (but still have a namespace name)
The <a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-URI-reference"> RDF URI Reference reference represented by a QName is determined by appending the local name part of the QName to the URI Reference associated with after the namespace prefix name (URI reference) part of the QName. This is used to shorten the <a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-URI-reference"> RDF URI References references of all property arcs labels predicates and some nodes. <a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-URI-reference"> RDF URI References references identifying subject and object nodes can also be stored as XML attribute values or XML element names via QNames. <a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-literal"> values. RDF Literals </a> (which are literals , which can only be object nodes) nodes, become either XML element text content or XML attribute values.
A graph can be considered a collection of paths of the form Node, Arc, Node, Arc, Node, Arc, node, predicate arc, node, predicate arc, node, predicate arc, ... Node node which cover the entire graph. In RDF/XML these turn into sequences of elements inside elements which alternate between elements for Nodes nodes and Arcs. predicate arcs. This has been called a series of Node/Arc node/arc stripes. The Node node at the start of the sequence turns into the outermost element, the next predicate arc turns into a child element, and so on. The stripes generally start at the top of an RDF/XML document and always begin with nodes.
Several RDF/XML examples are given in the following sections building up to complete RDF/XML documents. Example 7 is the first complete RDF/XML document.
An RDF Graph graph is given in Figure 1 where the nodes are represented as ovals and contain their <a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-URI-reference"> RDF URI References references where they have them, all the predicate arcs are labeled with <a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-URI-reference"> RDF URI References references and <a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-plain-literal"> Plain Literal plain literal nodes have been written in rectangles.
If we follow one Node, Arc node, predicate arc ... , Node node path through the graph shown in Figure 2 :
This The left hand side of the Figure 2 graph corresponds to the Node/Arc node/predicate arc stripes:
http://www.w3.org/TR/rdf-syntax-grammar
http://example.org/terms/editor
http://example.org/terms/homePage
http://purl.org/net/dajobe/
In
RDF/XML,
the
sequence
of
5
nodes
and
predicate
arcs
in
on
the
left
hand
side
of
Figure
2
corresponds
to
the
usage
of
5
five
XML
elements
of
two
types,
for
the
graph
nodes
and
predicate
arcs.
These
are
conventionally
called
Node
Elements
node
elements
and
Property
Elements
property
elements
respectively.
In
the
striping
shown
in
Example
1
,
rdf:Description
is
the
node
element
(used
3
three
times
for
the
three
nodes)
and
ex:editor
and
ex:homePage
are
the
2
two
property
elements.
<rdf:Description>
<ex:editor>
<rdf:Description>
<ex:homePage>
<rdf:Description>
</rdf:Description>
</ex:homePage>
</rdf:Description>
</ex:editor>
</rdf:Description>
The
Figure
2
graph
consists
of
some
nodes
that
are
<a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-URI-reference">
RDF
URI
References
references
(and
others
that
are
not)
and
this
can
be
added
to
the
RDF/XML
using
the
rdf:about
attribute
on
node
elements
to
give
the
result
in
Example
2
:
<rdf:Description rdf:about="http://www.w3.org/TR/rdf-syntax-grammar"> <ex:editor> <rdf:Description> <ex:homePage> <rdf:Description rdf:about="http://purl.org/net/dajobe/"> </rdf:Description> </ex:homePage> </rdf:Description> </ex:editor> </rdf:Description>
Adding the other two paths through the Figure 1 graph to the RDF/XML in Example 2 gives the result in Example 3 (this example fails to show that the blank node is shared between the two paths, see 2.10 ):
<rdf:Description rdf:about="http://www.w3.org/TR/rdf-syntax-grammar"> <ex:editor> <rdf:Description> <ex:homePage> <rdf:Description rdf:about="http://purl.org/net/dajobe/"> </rdf:Description> </ex:homePage> </rdf:Description> </ex:editor> </rdf:Description> <rdf:Description rdf:about="http://www.w3.org/TR/rdf-syntax-grammar"> <ex:editor> <rdf:Description> <ex:fullName>Dave Beckett</ex:fullName> </rdf:Description> </ex:editor> </rdf:Description> <rdf:Description rdf:about="http://www.w3.org/TR/rdf-syntax-grammar"> <dc:title>RDF/XML Syntax Specification (Revised)</dc:title> </rdf:Description>
There are several abbreviations that can be used to make common uses easier to write down. In particular, it is common that a subject node in the RDF Graph graph has multiple outgoing predicate arcs. RDF/XML provides an abbreviation for the corresponding syntax when a node element about a resource has multiple property elements. This can be abbreviated by using multiple child property elements inside the node element describing the subject node.
Taking
Example
3
,
there
are
two
node
elements
that
can
take
multiple
property
elements.
The
subject
node
with
URI
Reference
reference
http://www.w3.org/TR/rdf-syntax-grammar
has
property
elements
ex:editor
and
ex:title
and
the
node
element
for
the
blank
node
can
take
ex:homePage
and
ex:fullName
.
This
abbreviation
gives
the
result
shown
in
Example
4
(this
example
does
show
that
there
is
a
single
blank
node):
<rdf:Description rdf:about="http://www.w3.org/TR/rdf-syntax-grammar"> <ex:editor> <rdf:Description> <ex:homePage> <rdf:Description rdf:about="http://purl.org/net/dajobe/"> </rdf:Description> </ex:homePage> <ex:fullName>Dave Beckett</ex:fullName> </rdf:Description> </ex:editor> <dc:title>RDF/XML Syntax Specification (Revised)</dc:title> </rdf:Description>
When
an
a
predicate
arc
in
an
RDF
Graph
graph
points
to
an
object
node
which
has
no
further
predicate
arcs,
which
appears
in
RDF/XML
as
an
empty
node
element
deleted text:
sequence
such
as
the
pair
<rdf:Description
rdf:about="...">
</rdf:Description>
</code>,
(or
<rdf:Description
rdf:about="..."
/>
)
this
form
can
be
shortened.
This
is
done
by
using
the
<a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-URI-reference">
RDF
URI
Reference
reference
of
the
object
node
as
the
value
of
an
XML
attribute
rdf:resource
on
the
containing
property
element
and
making
the
property
element
empty.
In
this
example,
the
property
element
ex:homePage
contains
an
empty
node
element
with
the
<a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-URI-reference">
RDF
URI
Reference
reference
http://purl.org/net/dajobe/
.
This
can
be
replaced
with
the
empty
property
element
form
giving
the
result
shown
in
Example
5
:
<rdf:Description rdf:about="http://www.w3.org/TR/rdf-syntax-grammar"> <ex:editor> <rdf:Description> <ex:homePage rdf:resource="http://purl.org/net/dajobe/"/> <ex:fullName>Dave Beckett</ex:fullName> </rdf:Description> </ex:editor> <dc:title>RDF/XML Syntax Specification (Revised)</dc:title> </rdf:Description>
When
a
property
element's
content
is
string
literal,
it
may
be
possible
to
use
it
as
an
XML
attribute
on
the
containing
node
element.
This
can
be
done
for
multiple
properties
on
the
same
node
element
only
if
the
property
element
name
is
not
repeated
(required
by
XML
-
—
attribute
names
are
unique
on
an
XML
element)
and
any
in-scope
xml:lang
on
the
property
element's
string
literal
(if
any)
are
the
same
(see
Section
2.7
)
This
abbreviation
is
known
as
a
Property
Attribute
and
can
be
applied
to
any
node
element
or
with
the
rdf:parseType="Resource"
form
(see
Section
2.11
).
This
abbreviation
can
also
be
used
when
the
property
element
is
rdf:type
and
it
has
an
rdf:resource
attribute
the
value
of
which
is
interpreted
as
a
<a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-URI-reference">
RDF
URI
Reference
reference
object
node.
In
Example
5
:,
there
are
two
property
elements
with
string
literal
content,
the
dc:title
and
ex:fullName
property
elements.
These
can
be
replaced
with
property
attributes
giving
the
result
shown
in
Example
6
:
<rdf:Description rdf:about="http://www.w3.org/TR/rdf-syntax-grammar" dc:title="RDF/XML Syntax Specification (Revised)"> <ex:editor> <rdf:Description ex:fullName="Dave Beckett"> <ex:homePage rdf:resource="http://purl.org/net/dajobe/"/> </rdf:Description> </ex:editor> </rdf:Description>
To
create
a
complete
RDF/XML
document,
the
serialization
of
the
graph
into
XML
must
be
is
usually
contained
inside
an
rdf:RDF
XML
element
which
becomes
the
top-level
XML
document
element.
Conventionally
the
rdf:RDF
element
is
also
used
to
declare
the
XML
namespaces
that
are
used,
although
that
is
not
required.
When
there
is
only
one
top-level
node
element
inside
rdf:RDF
,
the
rdf:RDF
can
be
omitted
although
any
XML
namespaces
must
still
be
declared.
The XML specification also permits an XML declaration at the top of the document with the XML version and possibly the XML content encoding (this encoding. This is optional but recommended). recommended.
This Completing the RDF/XML could be done for any of the correct complete graph examples from Example 4 onwards but taking the smallest Example 6 and adding the final components, gives a complete RDF/XML representation of the original Figure 1 graph in Example 7 :
<?xml version="1.0"?> <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:ex="http://example.org/stuff/1.0/"> <rdf:Description rdf:about="http://www.w3.org/TR/rdf-syntax-grammar" dc:title="RDF/XML Syntax Specification (Revised)"> <ex:editor> <rdf:Description ex:fullName="Dave Beckett"> <ex:homePage rdf:resource="http://purl.org/net/dajobe/" /> </rdf:Description> </ex:editor> </rdf:Description> </rdf:RDF>
It
is
possible
to
omit
rdf:RDF
in
Example
7
above
since
there
is
only
one
rdf:Description
inside
rdf:RDF
but
this
is
not
shown
here.
xml:lang
RDF/XML
permits
the
use
of
the
xml:lang
attribute
as
defined
by
2.12
Language
Identification
of
XML
1.0
[XML]
to
allow
the
identification
of
content
language.
This
The
xml:lang
attribute
can
be
used
on
any
node
element
or
property
element
to
indicate
that
the
included
content
is
in
the
given
language.
Typed
literals
which
includes
XML
literals
are
not
affected
by
this
attribute.
The
most
specific
in-scope
language
present
(if
any)
is
applied
to
property
element
string
literal
content
or
property
attribute
values.
The
xml:lang=""
form
indicates
the
absence
of
a
language
identifier.
Some examples of marking content languages for RDF properties are shown in Example 8 :
<?xml version="1.0" encoding="iso-8859-1"?> <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:dc="http://purl.org/dc/elements/1.1/"> <rdf:Description rdf:about="http://www.w3.org/TR/rdf-syntax-grammar"> <dc:title>RDF/XML Syntax Specification (Revised)</dc:title> <dc:title xml:lang="en">RDF/XML Syntax Specification (Revised)</dc:title> <dc:title xml:lang="en-US">RDF/XML Syntax Specification (Revised)</dc:title> </rdf:Description> <rdf:Description rdf:about="http://example.org/buchen/baum" xml:lang="de"> <dc:title>Das Baum</dc:title> <dc:description>Das Buch ist außergewöhnlich</dc:description> <dc:title xml:lang="en">The Tree</dc:title> </rdf:Description> </rdf:RDF>
rdf:parseType="Literal"
RDF
allows
<a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-rdf-XMLLiteral">
XML
Literals
literals
(
[RDF-CONCEPTS]
Section
5,
XML
Content
within
an
RDF
Graph
graph
)
to
be
given
as
the
object
node
of
arcs.
a
predicate.
These
are
written
in
RDF/XML
as
content
of
a
property
element
(not
a
property
attribute)
and
indicated
using
the
rdf:parseType="Literal"
attribute
on
the
containing
property
element.
An
example
of
writing
an
XML
literal
is
given
in
Example
9
where
there
is
a
single
RDF
triple
with
the
subject
node
<a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-URI-reference">
RDF
URI
Reference
reference
http://example.org/item01
,
the
arc
label
<a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-URI-reference">
predicate
RDF
URI
Reference
reference
http://example.org/stuff/1.0/prop
(from
ex:prop
)
and
the
object
node
with
XML
Literal
literal
content
beginning
a:Box
</code>
.
<?xml version="1.0"?> <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:ex="http://example.org/stuff/1.0/"> <rdf:Description rdf:about="http://example.org/item01"> <ex:prop rdf:parseType="Literal" xmlns:a="http://example.org/a#"><a:Box required="true"> <a:widget size="10" /> <a:grommit id="23" /></a:Box> </ex:prop> </rdf:Description> </rdf:RDF>
rdf:datatype
RDF
allows
<a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-typed-literal">
Typed
Literals
typed
literals
to
be
given
as
the
object
node
of
arcs.
These
a
predicate.
Typed
literals
consist
of
a
literal
string
deleted text:
(with
optional
language)
and
a
datatype
<a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-URI-reference">
RDF
URI
Reference
reference
.
This
is
handled
by
These
are
written
in
RDF/XML
using
the
same
syntax
for
literal
string
nodes
in
the
property
element
form
(not
property
attribute)
but
with
an
additional
rdf:datatype="
datatypeURI
"
attribute
on
the
property
element.
Any
<a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-URI-reference">
RDF
URI
Reference
reference
can
be
used
in
the
attribute.
An
example
of
an
RDF
<a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-typed-literal">
Typed
Literal
typed
literal
is
given
in
Example
10
where
there
is
a
single
RDF
triple
with
the
subject
node
<a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-URI-reference">
RDF
URI
Reference
reference
http://example.org/item01
,
the
arc
label
<a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-URI-reference">
predicate
RDF
URI
Reference
reference
http://example.org/stuff/1.0/size
(from
ex:size
)
and
the
object
node
with
the
<a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-typed-literal">
Typed
Literal
typed
literal
("123",
http://www.w3.org/2001/XMLSchema#int
deleted text:
</code>,
no
language
<code>
xml:lang=""
)
deleted text:
intending
to
be
interpreted
as
a
<a href="http://www.w3.org/TR/xmlschema-2/#int">
an
W3C
XML
Schema
[XML-SCHEMA2]
datatype
int
</a>.
int.
<?xml version="1.0"?> <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:ex="http://example.org/stuff/1.0/"> <rdf:Description rdf:about="http://example.org/item01"> <ex:size rdf:datatype="http://www.w3.org/2001/XMLSchema#int">123</ex:size> </rdf:Description> </rdf:RDF>
rdf:nodeID
<a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-blank-node">
Blank
Nodes
nodes
in
the
RDF
Graph
graph
are
distinct
but
have
no
<a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-URI-reference">
RDF
URI
Reference
reference
identifier.
It
is
sometimes
required
that
the
same
graph
<a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-blank-node">
Blank
Node
blank
node
is
referred
to
in
the
RDF/XML
in
multiple
places,
such
as
at
the
subject
and
object
of
several
RDF
triples.
In
this
case,
a
<a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-blank-node-id">
Blank
Node
Identifier
blank
node
identifier
can
be
given
to
the
<a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-blank-node">
Blank
Node
blank
node
for
identifying
it
in
the
document.
Blank
node
identifiers
in
RDF/XML
are
scoped
to
the
containing
XML
Information
Set
Document
Information
Item
document
information
item
.
A
<a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-blank-node-id">
Blank
Node
Identifier
blank
node
identifier
is
used
on
a
node
element
to
replace
rdf:about="
RDF
URI
Reference
reference
"
or
on
a
property
element
to
replace
rdf:resource="
RDF
URI
Reference
reference
"
with
rdf:nodeID="
<a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-blank-node-id">
Blank
Node
Identifier
blank
node
identifier
"
in
both
cases.
Taking
Example
7
and
explicitly
giving
a
<a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-blank-node-id">
Blank
Node
Identifier
blank
node
identifier
of
abc
to
the
blank
node
in
it
gives
the
result
shown
in
Example
11
.
The
second
rdf:Description
property
element
is
about
the
blank
node.
rdf:nodeID
identifying
the
blank
node
(
example11.rdf
output
example11.nt
)
<?xml version="1.0"?> <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:ex="http://example.org/stuff/1.0/"> <rdf:Description rdf:about="http://www.w3.org/TR/rdf-syntax-grammar" dc:title="RDF/XML Syntax Specification (Revised)"> <ex:editor rdf:nodeID="abc"/> </rdf:Description> <rdf:Description rdf:nodeID="abc" ex:fullName="Dave Beckett"> <ex:homePage rdf:resource="http://purl.org/net/dajobe/"/> </rdf:Description> </rdf:RDF>
rdf:parseType="Resource"
<a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-blank-node">
Blank
Nodes
nodes
(not
<a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-URI-reference">
RDF
URI
Reference
reference
nodes)
in
RDF
Graphs
graphs
can
be
written
writtena
in
a
form
that
allows
the
<rdf:Description>
</rdf:Description>
pair
to
be
omitted.
This
can
be
The
omission
is
done
by
putting
an
rdf:parseType="Resource"
attribute
on
the
containing
property
element
that
turns
the
property
element
into
a
property
and
node
property-and-node
element,
which
can
itself
have
both
property
elements
and
property
attributes.
Property
attributes
and
the
rdf:nodeID
attribute
are
not
permitted
on
such
property
property-and-node
elements.
Taking
the
earlier
Example
7
,
the
contents
of
the
ex:editor
property
element
could
be
alternatively
done
in
this
fashion
to
give
the
form
shown
in
Example
12
:
<?xml version="1.0"?> <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:ex="http://example.org/stuff/1.0/"> <rdf:Description rdf:about="http://www.w3.org/TR/rdf-syntax-grammar" dc:title="RDF/XML Syntax Specification (Revised)"> <ex:editor rdf:parseType="Resource"> <ex:fullName>Dave Beckett</ex:fullName> <ex:homePage rdf:resource="http://purl.org/net/dajobe/"/> </ex:editor> </rdf:Description> </rdf:RDF>
If
all
of
the
property
elements
on
a
blank
node
element
have
string
literal
values
with
the
same
in-scope
xml:lang
value
(if
present)
and
each
of
these
property
elements
appears
at
most
once
and
there
is
at
most
one
rdf:type
property
element
with
a
<a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-URI-reference">
RDF
URI
Reference
reference
object
node,
these
can
be
abbreviated
by
moving
them
to
be
property
attributes
on
the
containing
property
element
which
is
made
an
empty
element.
Taking
the
earlier
Example
5
,
the
ex:editor
property
element
contains
a
blank
node
element
with
two
property
elements
ex:fullname
and
ex:homePage
.
ex:homePage
is
not
suitable
here
since
it
does
not
have
a
string
literal
value,
so
it
is
being
ignored
</em>.
for
the
purposes
of
this
example.
The
abbreviated
form
moves
removes
the
ex:fullName
property
element
to
be
and
adds
a
new
property
attribute
deleted text:
on
the
ex:editor
ex:fullName
with
the
string
literal
value
of
the
deleted
property
element
and
to
the
ex:editor
property
element.
The
blank
node
element
becomes
implicit.
implicit
in
the
now
empty
ex:editor
property
element.
The
result
is
shown
in
Example
13
.
<?xml version="1.0"?> <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:ex="http://example.org/stuff/1.0/"> <rdf:Description rdf:about="http://www.w3.org/TR/rdf-syntax-grammar" dc:title="RDF/XML Syntax Specification (Revised)"> <ex:editor ex:fullName="Dave Beckett" /> <!-- Note the ex:homePage property has been ignored for this example --> </rdf:Description> </rdf:RDF>
It
is
common
for
RDF
Graphs
graphs
to
have
rdf:type
arcs
predicates
from
subject
nodes.
These
are
conventionally
called
Typed
Nodes
typed
nodes
in
the
graph,
or
Typed
Node
Elements
typed
node
elements
in
the
RDF/XML.
RDF/XML
allows
this
triple
to
be
expressed
more
concisely.
by
replacing
the
rdf:Description
node
element
name
with
the
namespaced-element
corresponding
to
the
<a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-URI-reference">
RDF
URI
Reference
reference
of
the
value
of
the
type
relationship.
There
may,
of
course,
be
multiple
rdf:type
arcs
predicates
but
only
one
can
be
used
in
this
way,
the
others
must
remain
as
property
elements
or
property
attributes.
This
form
is
also
The
typed
node
elements
are
commonly
used
in
RDF/XML
with
the
built-in
classes
in
the
deleted text:
The
RDF
Namespace
vocabulary
:
rdf:Seq
,
rdf:Bag
,
rdf:Alt
,
rdf:Statement
,
rdf:Property
and
rdf:List
.
For example, the RDF/XML in Example 14 could be written as shown in Example 15 .
<?xml version="1.0"?> <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:ex="http://example.org/stuff/1.0/"> <rdf:Description rdf:about="http://example.org/thing"> <rdf:type rdf:resource="http://example.org/stuff/1.0/Document"/> <dc:title>A marvelous thing</dc:title> </rdf:Description> </rdf:RDF>
rdf:type
(
example15.rdf
output
example15.nt
)
<?xml version="1.0"?> <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:ex="http://example.org/stuff/1.0/"> <ex:Document rdf:about="http://example.org/thing"> <dc:title>A marvelous thing</dc:title> </ex:Document> </rdf:RDF>
rdf:ID
and
xml:base
RDF/XML
allows
further
abbreviating
<a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-URI-reference">
RDF
URI
References
references
in
XML
attributes
in
two
ways.
The
XML
Infoset
provides
a
base
URI
attribute
xml:base
that
sets
the
base
URI
for
resolving
relative
<a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-URI-reference">
RDF
URI
References
references
,
otherwise
the
base
URI
is
that
of
the
document.
This
The
base
URI
applies
to
all
RDF/XML
attributes
that
deal
with
<a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-URI-reference">
RDF
URI
References
references
which
are
rdf:about
,
rdf:resource
,
rdf:ID
deleted text:
</code>,
<code>
rdf:bagID
and
rdf:datatype
.
The
rdf:ID
attribute
on
a
node
element
(not
property
element,
that
has
another
meaning)
can
be
used
instead
of
rdf:about
and
gives
a
relative
<a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-URI-reference">
RDF
URI
Reference
reference
equivalent
to
#
concatenated
with
the
rdf:ID
attribute
value.
So
for
example
if
rdf:ID="name"
,
that
would
be
equivalent
to
rdf:about="#name"
.
This
rdf:ID
provides
an
additional
check
since
the
same
name
can
only
appear
once
in
the
scope
of
an
xml:base
value
(or
document,
if
none
is
given),
so
is
useful
for
defining
a
set
of
distinct,
related
terms
relative
to
the
same
<a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-URI-reference">
RDF
URI
Reference
reference
.
Both
forms
require
a
base
URI
to
be
known,
either
from
an
in-scope
xml:base
or
from
the
URI
of
the
RDF/XML
document.
Example
16
shows
abbreviating
the
node
<a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-URI-reference">
RDF
URI
Reference
reference
of
http://example.org/here/#snack
using
an
xml:base
of
http://example.org/here/
and
an
rdf:ID
on
the
rdf:Description
node
element.
The
object
node
of
the
ex:prop
arc
predicate
is
an
absolute
<a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-URI-reference">
RDF
URI
Reference
reference
resolved
from
the
rdf:resource
XML
attribute
content
value
using
the
in-scope
base
URI
to
give
the
<a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-URI-reference">
RDF
URI
Reference
reference
http://example.org/here/fruit/apple
.
rdf:ID
and
xml:base
for
shortening
URis
URIs
(
example16.rdf
output
example16.nt
)
<?xml version="1.0"?> <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:ex="http://example.org/stuff/1.0/" xml:base="http://example.org/here/"> <rdf:Description rdf:ID="snack"> <ex:prop rdf:resource="fruit/apple"/> </rdf:Description> </rdf:RDF>
rdf:li
and
rdf:_
n
RDF
has
a
set
of
container
membership
properties
and
corresponding
property
elements
that
are
mostly
used
with
instances
of
the
rdf:Seq
,
rdf:Bag
and
rdf:Alt
classes
which
may
be
written
as
typed
node
elements.
The
list
properties
are
rdf:_1
,
rdf:_2
etc.
and
can
be
written
as
property
elements
or
property
attributes
as
shown
in
Example
17
.
There
is
an
rdf:li
special
property
element
that
is
equivalent
to
rdf:_1
,
rdf:_2
in
order,
explained
in
detail
in
section
7.4
.
The
mapping
to
the
container
membership
properties
is
always
done
in
the
order
that
the
rdf:li
special
property
elements
appear
in
XML
—
the
document
order
is
significant.
The
equivalent
RDF/XML
to
Example
17
written
in
this
form
is
shown
in
Example
18
.
<?xml version="1.0"?> <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"> <rdf:Seq rdf:about="http://example.org/favourite-fruit"> <rdf:_1 rdf:resource="http://example.org/banana"/> <rdf:_2 rdf:resource="http://example.org/apple"/> <rdf:_3 rdf:resource="http://example.org/pear"/> </rdf:Seq> </rdf:RDF>
rdf:li
property
element
for
list
properties
(
example18.rdf
output
example18.nt
)
<?xml version="1.0"?> <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"> <rdf:Seq rdf:about="http://example.org/favourite-fruit"> <rdf:li rdf:resource="http://example.org/banana"/> <rdf:li rdf:resource="http://example.org/apple"/> <rdf:li rdf:resource="http://example.org/pear"/> </rdf:Seq> </rdf:RDF>
rdf:parseType="Collection"
RDF/XML
allows
an
rdf:parseType="Collection"
attribute
on
a
property
element
to
let
it
contain
multiple
node
elements.
These
contained
node
elements
give
the
set
of
subject
nodes
of
the
collection.
This
syntax
form
corresponds
to
a
set
of
triples
connecting
the
collection
of
subject
nodes,
the
exact
triples
generated
are
described
in
detail
in
Section
7.2.19
Production
parseTypeCollectionPropertyElt
.
The
collection
construction
is
always
done
in
the
order
that
the
node
elements
appear
in
the
XML
document.
Whether
the
order
of
the
collection
of
nodes
is
significant
is
an
application
issue
and
not
defined
here.
Example
19
shows
a
collection
of
three
nodes
elements
at
the
end
of
the
ex:hasFruit
property
element
using
this
form.
rdf:parseType="Collection"
(
example19.rdf
output
example19.nt
)
<?xml version="1.0"?> <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:ex="http://example.org/stuff/1.0/"> <rdf:Description rdf:about="http://example.org/basket"> <ex:hasFruit rdf:parseType="Collection"> <rdf:Description rdf:about="http://example.org/banana"/> <rdf:Description rdf:about="http://example.org/apple"/> <rdf:Description rdf:about="http://example.org/pear"/> </ex:hasFruit> </rdf:Description> </rdf:RDF>
rdf:ID
The
rdf:ID
attribute
can
be
used
on
a
property
element
to
reify
the
triple
that
it
generates
(See
section
7.3
Reification
Rules
for
the
full
details).
The
identifier
for
the
triple
should
be
constructed
as
a
<a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-URI-reference">
RDF
URI
Reference
reference
made
from
the
relative
URI
Reference
reference
#
concatenated
with
the
rdf:ID
attribute
value,
resolved
against
the
in-scope
base
URI.
So
for
example
if
rdf:ID="triple"
,
that
would
be
equivalent
to
the
<a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-URI-reference">
RDF
URI
Reference
reference
formed
from
relative
URI
Reference
reference
#triple
against
the
base
URI.
Each
(
rdf:ID
attribute
value,
base
URI)
pair
has
to
be
unique
in
an
RDF/XML
document
and
comes
from
the
same
set
of
values
as
the
<code>
rdf:bagID
</code>
attribute.
See
document,
see
constraint-id
.
Example
20
shows
a
rdf:ID
being
used
to
reify
a
triple
made
from
the
ex:prop
property
element
giving
the
reified
triple
the
<a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-URI-reference">
RDF
URI
Reference
reference
http://example.org/triples/#triple1
.
rdf:ID
reifying
a
property
element
(
example20.rdf
output
example20.nt
)
<?xml version="1.0"?> <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:ex="http://example.org/stuff/1.0/" xml:base="http://example.org/triples/"> <rdf:Description rdf:about="http://example.org/"> <ex:prop rdf:ID="triple1">blah</ex:prop> </rdf:Description> </rdf:RDF>
The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in RFC 2119 [KEYWORDS] .
All use of string without further qualification refers to a Unicode [UNICODE] character string; a sequence of characters represented by a code point in Unicode. (Such as defined in [CHARMOD] in section 3.4 Strings ).
The
Internet
Media
Type
media
type
/
MIME
type
for
RDF
RDF/XML
is
"
application/rdf+xml
"
-
—
see
RFC
3032
deleted text:
(
RFC-3023
[RFC-3023]
deleted text:
)
section
8.18.
Registration Note: Note (Informative): The RDF Core Working Group will register this type with the IETF after this document has passed For the Working Draft state, possibly after <a href="http://www.w3.org/Consortium/Process/Process-19991111/tr.html#RecsW3C"> Recommendation </a>, using state of the <cite> application/rdf+xml MIME type registration, consult IANA MIME Media Type Registration </cite> Internet Draft <a href="#ref-rdf-mimetype-id"> [RDF-MIMETYPE-ID] Types [ [IANA-MEDIA-TYPES] deleted text: already published and maintained.
It
is
recommended
that
RDF
RDF/XML
files
have
the
extension
".rdf"
(all
lowercase)
on
all
platforms.
It
is
recommended
that
RDF
RDF/XML
files
stored
on
Macintosh
HFS
file
systems
be
given
a
file
type
of
"rdf "
(all
lowercase,
with
a
space
character
as
the
fourth
letter).
Note:
Note
(Informative):
The
names
aboutEach
and
aboutEachPrefix
were
removed
from
the
language
and
the
RDF
namespace
vocabulary
by
the
RDF
Core
Working
Group.
See
the
resolution
of
issues
rdfms-abouteach
and
rdfms-abouteachprefix
for
further
information.
Note:
Note
(Informative):
The
names
List
,
first
,
rest
and
nil
were
added
for
issue
rdfms-seq-representation
.
The
names
XMLLiteral
and
datatype
were
added
to
support
RDF
datatyping.
The
name
nodeID
was
added
for
issue
rdfms-syntax-incomplete
.
See
the
RDF
Core
Issues
List
for
further
information.
The
RDF
Namespace
namespace
URI
Reference
reference
(or
namespace
name)
is
http://www.w3.org/1999/02/22-rdf-syntax-ns#
and
is
typically
used
in
XML
with
the
prefix
rdf
although
other
prefix
strings
may
be
used.
The
RDF
Vocabulary
is
identified
by
this
namespace
contains
name
and
consists
of
the
following
names
only:
RDF
Description
ID
about
deleted text:
bagID
parseType
resource
li
nodeID
datatype
Seq
Bag
Alt
Statement
Property
XMLLiteral
List
subject
predicate
object
type
value
first
rest
_
n
where
n
is
a
decimal
integer
greater
than
zero
with
no
leading
zeros.
nil
Any other names are not defined and SHOULD generate a warning when encountered, but should otherwise behave normally.
Within RDF/XML documents it is not permitted to use XML namespaces whose namespace URI name is deleted text: either: </p> <ul> <li> the · RDF Namespace namespace URI Reference reference · concatenated with additional characters. <strong> or </strong> </li> <li> the <a href="http://www.w3.org/TR/REC-xml-names/#nsc-NSDeclared"> XML Namespace URI reference </a> concatenated with additional characters. </li> </ul>
Throughout
this
document
the
terminology
rdf:
name
will
be
used
to
indicate
name
is
from
the
RDF
namespace
vocabulary
and
it
has
a
<a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-URI-reference">
RDF
URI
Reference
reference
of
the
concatenation
of
the
·
RDF
Namespace
namespace
URI
Reference
reference
·
and
name
.
For
example,
rdf:type
has
the
<a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-URI-reference">
RDF
URI
Reference
reference
http://www.w3.org/1999/02/22-rdf-syntax-ns#type
The <a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-rdf-graph"> RDF Graph ( <a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/"> RDF Concepts and Abstract Syntax Section 3) defines three types of nodes and one type of arc: predicate:
<a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-URI-reference"> RDF URI References references ( <a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/"> RDF Concepts and Abstract Syntax Section 3.1) can be either either:
rdf:ID
deleted text:
and
<code>
rdf:bagID
</code>
attribute
values.
</p>
Within
RDF/XML,
XML
QNames
are
transformed
into
<a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-URI-reference">
RDF
URI
References
references
by
appending
the
XML
local
name
to
the
namespace
URI.
name
(URI
reference).
For
example,
if
the
XML
Namespace
namespace
prefix
foo
has
URI
namespace
name
(URI
reference)
http://example.org/somewhere/
then
the
QName
foo:bar
would
correspond
to
the
RDF
URI
reference
http://example.org/somewhere/bar
.
Note
that
this
restricts
which
<a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-URI-reference">
RDF
URI
References
references
can
be
made
and
the
same
URI
can
be
given
in
multiple
ways.
The
rdf:ID
deleted text:
and
<a href="#bagIdAttr">
<code>
rdf:bagID
</code>
</a>
values
are
transformed
into
an
<a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-URI-reference">
RDF
URI
References
references
by
appending
the
attribute
value
to
the
result
of
appending
"#"
to
the
in-scope
base
URI
which
is
defined
in
Section
5.3
Resolving
URIs
<a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-literal"> RDF Literals literals ( <a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/"> RDF Concepts and Abstract Syntax 6.5) are either <a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-plain-literal"> Plain Literals plain literals (ibid), or <a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-typed-literal"> Typed Literals typed literals (ibid). The latter includes <a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-rdf-XMLLiteral"> XML Literals literals (ibid section 5, XML Content within an RDF Graph graph ).
<a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-blank-node">
Blank
Nodes
nodes
have
distinct
identity
in
the
RDF
Graph.
graph.
When
the
graph
is
written
in
a
syntax
such
as
RDF/XML,
these
blank
nodes
may
need
graph-local
identifiers
and
a
syntax
in
order
to
preserve
this
distinction.
These
local
identifiers
are
called
<a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-blank-node-id">
Blank
Node
Identifiers
blank
node
identifiers
and
are
used
in
RDF/XML
as
values
of
the
rdf:nodeID
attribute
with
the
syntax
given
in
Production
nodeIdAttr
.
Blank
node
identifiers
in
RDF/XML
are
scoped
to
the
XML
Information
Set
Document
Information
Item
document
information
item
.
These
identifiers
may
also
be
generated
If
no
blank
node
identifier
is
given
explicitly
as
part
of
the
mapping
from
the
RDF/XML
an
rdf:nodeID
attribute
value
then
one
will
need
to
the
graph
for
new
distinct
blank
nodes.
be
generated
(using
generated-blank-node-id,
see
section
6.3.3
).
Such
generated
blank
node
identifiers
must
not
clash
with
any
blank
node
identifiers
derived
from
rdf:nodeID
attribute
values.
This
can
be
implemented
by
any
method
that
preserves
the
distinct
identity
of
all
the
blank
nodes
in
the
graph.
graph,
that
is,
the
same
blank
node
identifier
is
not
given
for
different
blank
nodes.
One
possible
method
would
be
to
add
a
constant
prefix
to
all
the
rdf:nodeID
attribute
values
and
ensure
no
generated
blank
node
identifiers
ever
used
that
prefix.
Another
would
be
to
map
all
rdf:nodeID
attribute
values
to
new
generated
blank
node
identifiers
and
perform
that
mapping
on
all
such
values
in
the
RDF/XML
document.
RDF/XML
supports
XML
Base
[XML-BASE]
which
defines
a
·
base-uri
·
accessor
for
each
·
root
event
·
and
·
element
event
·
.
Relative
URI
References
references
are
resolved
into
<a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-URI-reference">
RDF
URI
References
references
according
to
the
algorithm
specified
in
XML
Base
[XML-BASE]
(and
RFC
2396).
These
specifications
do
not
specify
an
algorithm
for
resolving
a
fragment
identifier
alone,
such
as
#foo
,
or
the
empty
string
""
into
an
<a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-URI-reference">
RDF
URI
Reference
reference
.
In
RDF/XML,
a
fragment
identifier
is
transformed
into
a
<a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-URI-reference">
RDF
URI
Reference
reference
by
appending
the
fragment
identifier
to
the
in-scope
base
URI.
The
empty
string
is
transformed
into
an
<a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-URI-reference">
RDF
URI
Reference
reference
by
substituting
the
in-scope
base
URI.
Test: Indicated by test001.rdf and test001.nt
Test: Indicated by test004.rdf and test004.nt
Test: Indicated by test008.rdf and test008.nt
Test: Indicated by test013.rdf and test013.nt
Test: Indicated by test016.rdf and test016.nt
An empty same document reference "" resolves against the URI part of the Base base URI; any fragment part is ignored. See Uniform Resource Identifiers (URI) [URIS] section 4.2
Test: Indicated by test013.rdf and test013.nt
Implementor Note: Implementation Note (Informative): When using a hierarchical base URI that has no path component (/), it must be added before using as a base URI for resolving.
Test: Indicated by test011.rdf and test011.nt
Each application of productions production idAttr and <a href="#bagIdAttr"> bagIdAttr </a> match matches an attribute. The pair formed by the · string-value · accessor of the matched attribute and the · base-uri · accessor of the matched attribute is unique within a single RDF/XML document.
The syntax of the names must match the rdf-id production </a> .
Test: Indicated by test014.rdf and test014.nt
This document specifies the syntax of RDF/XML as a grammar on an alphabet of symbols. The symbols are called Events events in the style of the [XPATH] Information Set Mapping . A sequence of events is normally derived from an XML document, in which case they are in document order as defined below in Section 6.2 Information Set Mapping . This The sequence of these events formed form are intended to be similar to the sequence of events produced by the [SAX2] XML API from the same XML document. Sequences of events may be checked against the grammar to determine whether they are or are not syntactically well formed well-formed RDF/XML.
The grammar productions may include actions which fire when the production is recognised. recognized. Taken together these actions define a transformation from any syntactically well formed well-formed RDF/XML sequence of events into an RDF Graph graph represented in the <a href="http://www.w3.org/TR/2003/WD-rdf-testcases-20030123/#ntriples"> N-Triples language.
This The model given here illustrates one way to create a representation of an <a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-rdf-graph"> RDF Graph from an RDF/XML document. It does not mandate any implementation method - — any other method that results in a representation of the same <a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-rdf-graph"> RDF Graph may be used.
In particular:
The syntax does not support non-well-formed XML documents, nor documents that otherwise do not have an XML Information Set; for example, that do not conform to deleted text: XML Namespaces in XML [XML-NS] .
The Infoset requires support for XML Base [XML-BASE] . RDF/XML uses the information item property [base URI], discussed in section 5.3
This specification requires an XML Information Set [INFOSET] which supports at least the following information items and properties for RDF/XML:
There is no mapping of the following items to data model events:
Other information items and properties have no mapping to syntax data model events.
Information
Element
information
items
with
reserved
XML
Names
(See
Name
in
XML
1.0
)
are
not
mapped
to
data
model
element
events.
These
are
all
those
with
property
[prefix]
beginning
with
xml
(case
independent
comparison)
and
all
those
with
[prefix]
property
having
no
value
and
which
have
[local
name]
beginning
with
xml
(case
independent
comparison).
All information items contained inside XML elements matching the parseTypeLiteralPropertyElt production form <a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-rdf-XMLLiteral"> XML Literals literals and do not follow this mapping. See parseTypeLiteralPropertyElt for further information.
This section is intended to satisfy the requirements for Conformance in the [INFOSET] specification. It specifies the information items and properties that are needed to implement this specification.
There are six nine types of event defined in the following subsections. Most events are constructed from an Infoset information item (except for Identifier URI reference , blank node , Plain Literal plain literal and Typed Literal typed literal ). The effect of an event constructor is to create a new event with a unique identity, distinct from all other events. Events have accessor operations on them. them and all most have the string-value accessor that may be a static value or computed.
Constructed from a Document Information Item document information item and takes the following accessors and values.
Constructed from an Element Information Item element information item and takes the following accessors and values:
Set to Made from the value of element information item property [attributes]. [attributes] which is a set of attribute information items.
If
the
value
this
set
contains
an
attribute
event
information
item
xml:lang
(that
is,
the
<a href="#eventterm-attribute-local-name" class="termref">
<span class="arrow">
·
</span>
local-name
<span class="arrow">
·
</span>
</a>
accessor
of
(
[namespace
name]
property
with
the
deleted text:
attribute
has
value
"lang"
"http://www.w3.org/XML/1998/namespace"
and
the
<a href="#eventterm-attribute-namespace-name" class="termref">
<span class="arrow">
·
</span>
namespace-name
<span class="arrow">
·
</span>
</a>
accessor
of
the
attribute
has
[local
name]
property
value
"http://www.w3.org/XML/1998/namespace"),
"lang")
it
is
removed
from
the
list
set
of
attributes
attribute
information
items
and
the
·
language
·
accessor
is
set
to
the
string-value
[normalized-value]
property
of
the
attribute.
attribute
information
item.
All
other
attributes
remaining
reserved
XML
Names
(See
Name
in
XML
1.0
)
are
now
removed
from
the
set.
These
are,
all
attribute
information
items
in
the
set
with
property
[prefix]
beginning
with
xml
are
then
removed
(that
is,
(case
independent
comparison)
and
all
attributes
attribute
information
items
with
<a href="#eventterm-attribute-namespace-name" class="termref">
<span class="arrow">
·
</span>
namespace-name
<span class="arrow">
·
</span>
</a>
accessors
values
[prefix]
property
having
no
value
and
which
have
[local
name]
beginning
with
"http://www.w3.org/XML/1998/namespace").
Note:
xml
(case
independent
comparison)
are
removed.
Note
that
the
base
URI
[base
URI]
accessor
is
computed
by
XML
Base
before
any
xml:base
attribute
information
item
is
deleted.
The remaining set of attribute information items are then used to construct a new set of Attribute Events which is assigned as the value of this accessor.
Has no accessors. Marks the end of the containing element in the sequence.
Constructed from an Attribute Information Item attribute information item and takes the following accessors and values:
If
·
namespace-name
·
is
present,
set
to
a
string
value
of
the
concatenation
of
the
value
of
the
·
namespace-name
·
accessor
and
the
value
of
the
·
local-name
·
accessor.
Otherwise
if
·
local-name
·
is
ID
,
deleted text:
bagID
</code>,
<code>
about
,
resource
,
parseType
or
type
,
set
to
a
string
value
of
the
concatenation
of
the
·
RDF
Namespace
namespace
URI
Reference
reference
·
and
the
value
of
the
·
local-name
·
accessor.
Other
non-namespaced
·
local-name
·
accessor
values
are
forbidden.
This The support for a limited set of non-namespaced names is REQUIRED and intended to allow RDF/XML documents specified in [RDF-MS] to remain valid; new documents SHOULD NOT use these unqualified attributes and applications MAY choose to warn when the unqualified form is seen in a document.
The
construction
of
<a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-URI-reference">
RDF
URI
References
references
from
XML
attributes
can
generate
the
same
<a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-URI-reference">
RDF
URI
References
references
from
different
XML
attributes.
This
can
cause
ambiguity
in
the
grammar
when
matching
attribute
events
(such
as
when
rdf:about
and
about
XML
attributes
are
both
present).
Documents
that
have
this
are
illegal.
Constructed from a sequence of one or more consecutive Character Information Items character information items . Has the single accessor:
An event for a <a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-URI-reference"> RDF URI References references which has the following accessors:
The value is the concatenation of "<", the value of the · identifier · accessor and ">"
The <>-quoted · identifier · accessor value must use the N-Triples escapes for URI references as described in 3.3 URI References .
These events are constructed by giving a value for the · identifier · accessor.
For further information on identifiers in the RDF Graph, graph, see section 5.2 .
An event for a <a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-blank-node-id"> Blank Node Identifier blank node identifier which has the following accessors:
These events are constructed by giving a value for the · identifier · accessor.
For further information on identifiers in the RDF Graph, graph, see section 5.2 .
An event for a <a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-plain-literal"> Plain Literal plain literal which can have the following accessors:
The value is calculated from the other accessors as follows.
If · literal-language · is the empty string then the value is the concatenation of """ (1 double quote), the value of the 2 · literal-value · accessor and """ (1 double quote).
Otherwise the value is the concatenation of """ (1 double quote), the value of the · literal-value · accessor ""@" (1 double quote and a '@'), and the value of the · literal-language · accessor.
Note that the The double-quoted · literal-value · string accessor value must use the N-Triples <a href="http://www.w3.org/TR/2003/WD-rdf-testcases-20030123/#ntrip_strings"> string escapes for strings as described in 3.2 Strings for escaping certain characters such as ".
These events are constructed by giving values for the · literal-value · and · literal-language · accessors.
Note: Interoperability Note (Informative): Literals beginning with a Unicode combining character are allowed however they may cause interoperability problems. See [CHARMOD] for further information.
An event for a <a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-typed-literal"> Typed Literal typed literal which can have the following accessors:
The value is deleted text: calculated from the other accessors as follows. </p> <p> If <a href="#eventterm-typedliteral-literal-language" class="termref"> <span class="arrow"> · </span> literal-language <span class="arrow"> · </span> </a> is the empty string then the value is the concatenation of the following in this order """ (1 double quote), the value of the · literal-value · accessor and """ (1 double quote). </p> <p> Otherwise the value is the concatenation of accessor, """ (1 double quote), "^^<", the value of the <a href="#eventterm-typedliteral-literal-value" class="termref"> · literal-value literal-datatype · accessor deleted text: ""@" (1 double quote and a '@') and the value of the <a href="#eventterm-typedliteral-literal-language" class="termref"> <span class="arrow"> · </span> literal-language <span class="arrow"> · </span> </a> accessor. ">".
Finally, if <a href="#eventterm-typedliteral-literal-datatype" class="termref"> The double-quoted · literal-datatype literal-value · is not empty then append to the value calculated above "^^<" concatenated with the accessor value of must use the N-Triples escapes for strings as described in 3.2 Strings for escaping certain characters such as ". The <>-quoted · literal-datatype · accessor concatenated with ">". </p> <p> Note that the double-quoted literal-value string value must use the N-Triples deleted text: <a href="http://www.w3.org/TR/2003/WD-rdf-testcases-20030123/#ntrip_strings"> string escapes escapes for escaping certain characters such URI references as ". described in 3.3 URI References .
These events are constructed by giving values for the · literal-value · deleted text: </a>, <a href="#eventterm-typedliteral-literal-language" class="termref"> <span class="arrow"> · </span> literal-language <span class="arrow"> · </span> and · literal-datatype · accessors.
Note: Interoperability Note (Informative): Literals beginning with a Unicode combining character are allowed however they may cause interoperability problems. See [CHARMOD] for further information.
Implementation Note (Informative): In XML Schema (part 1) [XML-SCHEMA1] , white space normalization occurs during validation according to the value of the whiteSpace facet. The syntax mapping used in this document occurs after this, so the whiteSpace facet formally has no further effect.
To transform the Infoset into the sequence of events in document order , each information item is transformed as described above to generate a tree of events with accessors and values. Each element event is then replaced as described below to turn the tree of events into a sequence in document order.
The following notation is used for to describe matching the sequence of data model events deleted text: generated as described given in Section 6 and deleted text: describing the actions to perform for the matches. The RDF/XML grammar is defined deleted text: here in terms of its mapping from these matched data model events, events to triples, using statements notation of the form:
number event-type event-content
action ...
<a href="http://www.w3.org/TR/2003/WD-rdf-testcases-20030123/#ntriples"> N-Triples
where the event-content is an expression, which may refer to other expression matching event-types (as defined in Section 6.1 ), using constructs of the form notation given in the following table. sections. The number is used for reference purposes. The grammar action may include generating new triples to the graph, written in <a href="http://www.w3.org/TR/2003/WD-rdf-testcases-20030123/#ntriples"> N-Triples format.
<table border="1" summary="This table describes the notation used in the following sections to match sequences of events and perform grammar actions."> <caption> NotationThe following sections describe the general notation used and that for event matching deleted text: events and deleted text: grammar actions. </caption> <tr> <th colspan="2">
Notation | Meaning |
---|---|
event . accessor | The value of an event accessor. |
rdf:
X
|
A URI as defined in section 5.1 . |
"ABC" | A string of characters A, B, C in order. |
Notation | Meaning |
---|---|
A == B | Event accessor A is equal to matches expression B. |
A != B | A is not equal to B. |
A | B | ... | The A, B, ... terms are alternatives. |
A - B | The term terms in A but not excluding all the term terms in B. |
anyURI . | Any URI. |
anyString . | Any string. |
list(item1, item2, ...); list() | An ordered list of events. An empty list. |
set(item1, item2, ...); set() | An unordered set of events. An empty set. |
* | Zero or more of preceding term. |
? | Zero or one of preceding term. |
+ | One or more of preceding term. |
root(acc1
==
value1,
acc2 == value2, ...) |
Match a Root Event with accessors. |
start-element(acc1
==
value1,
acc2 == value2, ...) children end-element() |
Match a sequence of Element Event with accessors, a possibly empty list of events as element content and an End Element Event . |
attribute(acc1
==
value1,
acc2 == value2, ...) |
Match an Attribute Event with accessors. |
text() | Match a Text Event . |
Notation | Meaning |
---|---|
A := B | Assigns A the value B. |
concat(A, B, ..) | A string created by concatenating the terms in order. |
resolve( e , s ) | A string created by interpreting string s as a relative URI reference to the · base-uri · accessor of deleted text: <span class="arrow"> · </span> Element Event <span class="arrow"> · </span> e as defined in Section 5.3 Resolving URIs . The resulting string represents an <a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-URI-reference"> RDF URI Reference reference . |
generated-blank-node-id() | A string value for a new distinct generated <a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-blank-node-id"> Blank Node Identifier blank node identifier as defined in section 5.2 Identifiers . |
event . accessor := value | Sets an event accessor to the given value. |
uri(identifier := value) | Create a new URI Reference Event . |
bnodeid(identifier := value) | Create a new Blank Node Identifier Event . See also section 5.2 Identifiers . |
literal(literal-value
:=
string,
literal-language := language, ...) |
Create a new Plain Literal Event . |
typed-literal(literal-value := string, deleted text: <br /> literal-language := language, ...) | Create a new Typed Literal Event . |
7.2.2 coreSyntaxTerms |
rdf:RDF
|
rdf:ID
|
rdf:about
|
deleted text:
rdf:bagID
</code>
|
|
7.2.3 syntaxTerms |
coreSyntaxTerms
|
rdf:Description
|
rdf:li
|
7.2.4 oldTerms |
rdf:aboutEach
|
rdf:aboutEachPrefix
|
rdf:bagID
|
7.2.5 nodeElementURIs |
anyURI
-
(
coreSyntaxTerms
|
rdf:li
|
oldTerms
)
|
7.2.6 propertyElementURIs |
anyURI
-
(
coreSyntaxTerms
|
rdf:Description
|
oldTerms
)
|
7.2.7 propertyAttributeURIs |
anyURI
-
(
coreSyntaxTerms
|
rdf:Description
|
rdf:li
|
oldTerms
)
|
7.2.8 doc | root( document-element == RDF , children == list( RDF )) |
7.2.9 RDF |
start-element(
URI
==
rdf:RDF
,
attributes
==
set())
nodeElementList end-element() |
7.2.10 nodeElementList | ws * ( nodeElement ws * )* |
7.2.11 nodeElement |
start-element(
URI
==
nodeElementURIs
attributes == set(( idAttr | nodeIdAttr | aboutAttr  )?, deleted text: <a href="#bagIdAttr"> bagIdAttr </a> ?, propertyAttr *)) propertyEltList end-element() |
7.2.12 ws | A text event matching white space defined by [XML] definition White Space Rule [3] S in section Common Syntactic Constructs |
7.2.13 propertyEltList | ws * ( propertyElt ws * ) * |
7.2.14 propertyElt | resourcePropertyElt | literalPropertyElt | parseTypeLiteralPropertyElt | parseTypeResourcePropertyElt | parseTypeCollectionPropertyElt | parseTypeOtherPropertyElt | emptyPropertyElt |
7.2.15 resourcePropertyElt |
start-element(
URI
==
propertyElementURIs
),
attributes
==
set(
idAttr
?))
ws * nodeElement ws * end-element() |
7.2.16 literalPropertyElt |
start-element(
URI
==
propertyElementURIs
),
attributes
==
set(
idAttr
?,
datatypeAttr
?))
text() end-element() |
7.2.17 parseTypeLiteralPropertyElt |
start-element(
URI
==
propertyElementURIs
),
attributes
==
set(
idAttr
?,
parseLiteral
))
literal end-element() |
7.2.18 parseTypeResourcePropertyElt |
start-element(
URI
==
propertyElementURIs
),
attributes
==
set(
idAttr
?,
parseResource
))
propertyEltList end-element() |
7.2.19 parseTypeCollectionPropertyElt |
start-element(
URI
==
propertyElementURIs
),
attributes
==
set(
idAttr
?,
parseCollection
))
nodeElementList end-element() |
7.2.20 parseTypeOtherPropertyElt |
start-element(
URI
==
propertyElementURIs
),
attributes
==
set(
idAttr
?,
parseOther
))
propertyEltList end-element() |
7.2.21 emptyPropertyElt |
start-element(
URI
==
propertyElementURIs
),
attributes
==
set(
idAttr
?,
(
resourceAttr
|
nodeIdAttr
)?,
deleted text:
<a href="#bagIdAttr">
bagIdAttr
</a>
?,
propertyAttr
*))
end-element() |
7.2.22 idAttr |
attribute(
URI
==
rdf:ID
,
string-value
==
rdf-id
)
|
7.2.23 nodeIdAttr |
attribute(
URI
==
rdf:nodeID
,
string-value
==
rdf-id
)
|
7.2.24 aboutAttr |
attribute(
URI
==
rdf:about
,
string-value
==
URI-reference
)
|
deleted text: <a href="#bagIdAttr"> 7.2.25 </a> <a href="#bagIdAttr"> bagIdAttr </a> </td> <td> attribute( <a href="#eventterm-attribute-URI"> URI </a> == <code> rdf:bagID </code>, <a href="#eventterm-attribute-string-value"> string-value </a> == <a href="#rdf-id"> rdf-id </a> ) </td> </tr> <tr valign="top"> <td> 7.2.26 7.2.25 propertyAttr | attribute( URI == propertyAttributeURIs , string-value == anyString ) |
7.2.27 7.2.26 resourceAttr |
attribute(
URI
==
rdf:resource
,
string-value
==
URI-reference
)
|
7.2.28 7.2.27 datatypeAttr |
attribute(
URI
==
rdf:datatype
,
string-value
==
URI-reference
)
|
7.2.29 7.2.28 parseLiteral |
attribute(
URI
==
rdf:parseType
,
string-value
==
"Literal")
|
7.2.30 7.2.29 parseResource |
attribute(
URI
==
rdf:parseType
,
string-value
==
"Resource")
|
7.2.31 7.2.30 parseCollection |
attribute(
URI
==
rdf:parseType
,
string-value
==
"Collection")
|
7.2.32 7.2.31 parseOther |
attribute(
URI
==
rdf:parseType
,
string-value
==
anyString
-
("Resource"
|
"Literal")
"Literal"
|
"Collection")
)
|
7.2.33 7.2.32 URI-reference | An attribute · string-value · interpreted as representing an RDF URI Reference reference . |
7.2.34 7.2.33 literal | Any XML element content that is allowed according to [XML] definition Content of Elements Rule [43] content . in section 3.1 Start-Tags, End-Tags, and Empty-Element Tags |
7.2.35 7.2.34 rdf-id | An attribute · string-value · matching any legal [XML-NS] token NCName |
If the RDF/XML is a standalone XML document (known (identified by having been given the presentation as an application/rdf+xml RDF MIME Type type ) object, or by some other means) then the grammar starts may start with Root Event production doc or production nodeElement .
If the content is known to be RDF/XML by context, such as when RDF/XML is embedded inside other XML content, then the grammar can either start at Element Event RDF (only when an element is legal at that point in the XML) or at production nodeElementList (only when element content is legal, since this is a list of elements). For such embedded RDF/XML, the · base-uri · value on the outermost element must be initialized from the containing XML since no Root Event will be available. Note that if such embedding occurs, the grammar may be entered several times but no state is expected to be preserved.
rdf:RDF
|
rdf:ID
|
rdf:about
|
deleted text:
rdf:bagID
</code>
|
rdf:parseType
</code>
|
rdf:resource
|
rdf:nodeID
|
rdf:datatype
A subset of the syntax terms from the RDF Namespace vocabulary in section 5.1 which are used in RDF/XML.
coreSyntaxTerms
|
rdf:Description
|
rdf:li
All the syntax terms from the RDF Namespace vocabulary in section 5.1 which are used in deleted text: the RDF/XML.
rdf:aboutEach
|
rdf:aboutEachPrefix
|
rdf:bagID
These are the names from the RDF Namespace vocabulary that have been withdrawn from the language. See the resolutions of the Issue rdfms-aboutEach-on-object and , Issue rdfms-abouteachprefix issues and Last Call Issue timbl-01 for further information.
deleted text:Note: The Working Group invites feedback from the community on the effects of the removal of these terms on existing implementations and documents and on the costs and benefits of adopting a new namespace URI to reflect this change (currently not proposed by the Working Group).
rdf:li
|
oldTerms
)
The <a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-URI-reference"> RDF URI References references that are allowed on node elements.
anyURI
-
(
coreSyntaxTerms
|
rdf:Description
|
oldTerms
)
The URIs that are allowed on property elements.
anyURI
-
(
coreSyntaxTerms
|
rdf:Description
|
rdf:li
|
oldTerms
)
The <a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#dfn-URI-reference"> RDF URI References references that are allowed on property attributes.
root(
document-element
==
RDF
,
children
==
list(
RDF
))
start-element(
URI
==
rdf:RDF
,
attributes
==
set())
nodeElementList
end-element()
ws * ( nodeElement ws * )*
start-element(
URI
==
nodeElementURIs
attributes
==
set((
idAttr
|
nodeIdAttr
|
aboutAttr
 )?,
deleted text:
<a href="#bagIdAttr">
bagIdAttr
</a>
?,
propertyAttr
*))
propertyEltList
end-element()
For node element e , the processing of some of the attributes has to be done before other work such as dealing with children events or other attributes. These can be processed in any order:
rdf:ID
,
then
e
.
subject
:=
uri(
identifier
:=
resolve(
e
,
concat("#",
a
.
string-value
))).
rdf:nodeID
,
then
e
.
subject
:=
bnodeid(
identifier
:=
a
.
string-value
).
rdf:about
then
e
.
subject
:=
uri(
identifier
:=
resolve(
e
,
a
.
string-value
)).
If e . subject is empty, then e . subject := bnodeid( identifier := generated-blank-node-id()).
The following can then be performed in any order:
rdf:Description
then
the
following
statement
is
added
to
the
graph:
e
.
subject
.
string-value
<http://www.w3.org/1999/02/22-rdf-syntax-ns#type>
<
e
.
URI
>
.
rdf:type
then
the
following
statement
is
added
to
the
graph:
e
.
subject
.
string-value
<http://www.w3.org/1999/02/22-rdf-syntax-ns#type>
<
a
.
string-value
>
.
rdf:type
)
then
),
the
Unicode
string
a
.
string-value
SHOULD
be
in
Normal
Form
C
[NFC]
,
o
:=
literal(
literal-value
:=
a
.
string-value
,
literal-language
:=
e
.
language
)
and
the
following
statement
is
added
to
the
graph:
e
.
subject
.
string-value
<
a
.
URI
>
o
.
string-value
.
A text event matching white space defined by [XML] definition White Space Rule [3] S in section Common Syntactic Constructs
ws * ( propertyElt ws * ) *
If
element
e
has
e
.
URI
=
rdf:li
then
apply
the
list
expansion
rules
on
element
e
.parent
in
section
7.4
to
give
a
new
URI
u
and
e
.
URI
:=
u
.
deleted text: NOTE: The action of this production must be done before the actions of any sub-matches ( resourcePropertyElt ... emptyPropertyElt ). Alternatively the result must be equivalent to as if it this action was performed first, such as performing as the first action of all of the sub-matches.
start-element(
URI
==
propertyElementURIs
),
attributes
==
set(
idAttr
?))
ws
*
nodeElement
ws
*
end-element()
For element e , and the single contained nodeElement n , first n must be processed using production nodeElement . Then the following statement is added to the graph:
e
.parent.
subject
.
string-value
<
e
.
URI
>
n
.
subject
.
string-value
.
If
the
rdf:ID
attribute
a
is
given,
the
above
statement
is
reified
with
i
:=
uri(
identifier
:=
resolve(
e
,
concat("#",
a
.
string-value
)))
using
the
reification
rules
in
section
7.3
and
e
.
subject
:=
i
start-element(
URI
==
propertyElementURIs
),
attributes
==
set(
idAttr
?,
datatypeAttr
?))
text()
end-element()
<strong> Note: </strong> The Note that the empty literal case is defined in production emptyPropertyElt </a> .
deleted text: </div>
For
element
e
,
and
the
text
event
t
.
The
Unicode
string
t
.
string-value
SHOULD
be
in
Normal
Form
C
[NFC]
.
If
the
rdf:datatype
attribute
d
is
given
then
o
:=
typed-literal(
literal-value
:=
t
.
string-value
,
deleted text:
<a href="#eventterm-typedliteral-literal-language">
literal-language
</a>
:=
<em>
e
</em>.
<a href="#eventterm-element-language">
language
</a>,
literal-datatype
:=
a
d
.
string-value
)
otherwise
o
:=
literal(
literal-value
:=
t
.
string-value
,
literal-language
:=
e
.
language
)
and
the
following
statement
is
added
to
the
graph:
e
.parent.
subject
.
string-value
<
e
.
URI
>
o
.
string-value
.
If
the
rdf:ID
attribute
a
is
given,
the
above
statement
is
reified
with
i
:=
uri(
identifier
:=
resolve(
e
,
concat("#",
a
.
string-value
)))
using
the
reification
rules
in
section
7.3
and
e
.
subject
:=
i
.
start-element(
URI
==
propertyElementURIs
),
attributes
==
set(
idAttr
?,
parseLiteral
))
literal
end-element()
For
element
e
and
the
literal
l
</em>,
then
that
is
the
rdf:parseType="Literal"
content.
l
is
not
transformed
by
the
syntax
data
model
mapping
into
events
(as
noted
in
6
Syntax
Data
Model
)
but
remains
an
XML
Infoset
of
XML
Information
items.
l is transformed into the lexical form of an XML literal in the RDF graph x (a Unicode string) by the following algorithm. This does not mandate any implementation method — any other method that gives the same result may be used.
Then
o
:=
typed-literal(
literal-value
:=
l
</em>.
<a href="#eventterm-text-string-value">
string-value
</a>,
<a href="#eventterm-typedliteral-literal-language">
literal-language
</a>
:=
<em>
e
</em>.
<a href="#eventterm-element-language">
language
</a>,
x
,
literal-datatype
:=
http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral
)
and
the
following
statement
is
added
to
the
graph:
e
.parent.
subject
.
string-value
<
e
.
URI
>
o
.
string-value
.
Test: Empty literal case indicated by test009.rdf and test009.nt
If
the
rdf:ID
attribute
a
is
given,
the
above
statement
is
reified
with
i
:=
uri(
identifier
:=
resolve(
e
,
concat("#",
a
.
string-value
)))
using
the
reification
rules
in
section
7.3
and
e
.
subject
:=
i
.
start-element(
URI
==
propertyElementURIs
),
attributes
==
set(
idAttr
?,
parseResource
))
propertyEltList
end-element()
For element e with possibly empty element content c .
n := bnodeid( identifier := generated-blank-node-id()).
Add the following statement to the graph:
e
.parent.
subject
.
string-value
<
e
.
URI
>
n
.
string-value
.
Test: Indicated by test004.rdf and test004.nt
If
the
rdf:ID
attribute
a
is
given,
the
statement
above
is
reified
with
i
:=
uri(
identifier
:=
resolve(
e
,
concat("#",
a
.
string-value
)))
using
the
reification
rules
in
section
7.3
and
e
.
subject
:=
i
.
If the element content c is not empty, then use event n to create a new sequence of events as follows:
start-element(
URI
:=
rdf:Description
,
subject
:=
n
,
attributes
:=
set())
c
end-element()
Then process the resulting sequence using production nodeElement .
start-element(
URI
==
propertyElementURIs
),
attributes
==
set(
idAttr
?,
parseCollection
))
nodeElementList
end-element()
For element event e with possibly empty nodeElementList l . Set s :=list().
For each element event f in l , n := bnodeid( identifier := generated-blank-node-id()) and append n to s to give a sequence of events.
If s is not empty, n is the first event identifier in s and the following statement is added to the graph:
e
.parent.
subject
.
string-value
<
e
.
URI
>
n
.
string-value
.
otherwise the following statement is added to the graph:
e
.parent.
subject
.
string-value
<
e
.
URI
>
<http://www.w3.org/1999/02/22-rdf-syntax-ns#nil>
.
If
the
rdf:ID
attribute
a
is
given,
either
of
the
the
above
statement
statements
is
reified
with
i
:=
uri(
identifier
:=
resolve(
e
,
concat("#",
a
.
string-value
)))
using
the
reification
rules
in
section
7.3
.
If s is empty, no further work is performed.
For each event n in s deleted text: </em>, the following statement is added to the graph: </p> <div class="ntripleOuter"> <div class="ntripleInner"> <p> <code> <em> n </em>. <a href="#eventterm-identifier-string-value"> string-value </a> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://www.w3.org/1999/02/22-rdf-syntax-ns#List> . </code> </p> </div> </div> <p> For each event <em> n </em> in <em> s and the corresponding element event f in l , the following statement is added to the graph:
n
.
string-value
<http://www.w3.org/1999/02/22-rdf-syntax-ns#first>
f
.
string-value
.
For each consecutive, consecutive and overlapping pairs pair of events ( n , o ) in s , the following statement is added to the graph:
n
.
string-value
<http://www.w3.org/1999/02/22-rdf-syntax-ns#rest>
o
.
string-value
.
If s is not empty, n is the last event identifier in s , the following statement is added to the graph:
n
.
string-value
<http://www.w3.org/1999/02/22-rdf-syntax-ns#rest>
<http://www.w3.org/1999/02/22-rdf-syntax-ns#nil>
.
start-element(
URI
==
propertyElementURIs
),
attributes
==
set(
idAttr
?,
parseOther
))
propertyEltList
end-element()
All
rdf:parseType
attribute
values
other
than
the
strings
"Resource",
"Literal"
or
"Collection"
are
treated
as
if
the
value
was
"Literal".
This
production
matches
and
acts
as
if
production
parseTypeLiteralPropertyElt
was
matched.
No
extra
triples
are
generated
for
other
rdf:parseType
values.
start-element(
URI
==
propertyElementURIs
),
attributes
==
set(
idAttr
?,
(
resourceAttr
|
nodeIdAttr
)?,
deleted text:
<a href="#bagIdAttr">
bagIdAttr
</a>
?,
propertyAttr
*))
end-element()
If
there
are
no
attributes
or
only
the
optional
rdf:ID
attribute
i
then
o
:=
literal(
literal-value
:="",
literal-language
:=
e
.
language
)
and
the
following
statement
is
added
to
the
graph:
e
.parent.
subject
.
string-value
<
e
.
URI
>
o
.
string-value
.
and then if i is given, the above statement is reified with uri( identifier := resolve( e , concat("#", i . string-value ))) using the reification rules in section 7.3 .
Test: Indicated by test002.rdf and test002.nt
Test: Indicated by test005.rdf and test005.nt
Otherwise
rdf:resource
attribute
i
is
present,
then
r
:=
uri(
identifier
:=
resolve(
e
,
i
.
string-value
))
rdf:nodeID
attribute
i
is
present,
then
r
:=
bnodeid(
identifier
:=
i
.
string-value
)
deleted text: If optional <code> rdf:bagID </code> attribute <em> b </em> is given, <em> n </em> := uri( <a href="#eventterm-identifier-identifier"> identifier </a> := resolve( <em> e </em>, concat("#", <em> b </em>. <a href="#eventterm-attribute-string-value"> string-value </a> ))) </p> <p> The following are done in any order:
For all propertyAttr attributes a (in any order)
If
a
.
URI
==
rdf:type
then
the
following
statement
is
added
to
the
graph:
r
.
string-value
<http://www.w3.org/1999/02/22-rdf-syntax-ns#type>
<
a
.
string-value
>
.
Otherwise Unicode string a . string-value SHOULD be in Normal Form C [NFC] , o := literal( literal-value := a . string-value , literal-language := e . language ) and the following statement is added to the graph:
r
.
string-value
<
a
.
URI
>
o
.
string-value
.
Test: Indicated by test013.rdf and test013.nt
Test: Indicated by test014.rdf and test014.nt
Add the following statement to the graph:
e
.parent.
subject
.
string-value
<
e
.
URI
>
r
.
string-value
.
and
then
if
rdf:ID
attribute
i
is
given,
the
above
statement
is
reified
with
uri(
identifier
:=
resolve(
e
,
concat("#",
i
.
string-value
)))
using
the
reification
rules
in
section
7.3
.
attribute(
URI
==
rdf:ID
,
string-value
==
rdf-id
)
Constraint:
:
constraint-id
applies
to
the
values
of
rdf:ID
attributes
attribute(
URI
==
rdf:nodeID
,
string-value
==
rdf-id
)
attribute(
URI
==
rdf:about
,
string-value
==
URI-reference
)
attribute(
URI
==
propertyAttributeURIs
,
string-value
==
anyString
)
attribute(
URI
==
rdf:resource
,
string-value
==
URI-reference
)
attribute(
URI
==
rdf:datatype
,
string-value
==
URI-reference
)
attribute(
URI
==
rdf:parseType
,
string-value
==
"Literal")
attribute(
URI
==
rdf:parseType
,
string-value
==
"Resource")
attribute(
URI
==
rdf:parseType
,
string-value
==
"Collection")
attribute(
URI
==
rdf:parseType
,
string-value
==
anyString
-
("Resource"
|
"Literal")
"Literal"
|
"Collection")
)
Any XML element content that is allowed according to [XML] definition Content of Elements Rule [43] content . in section 3.1 Start-Tags, End-Tags, and Empty-Element Tags
The string-value for the resulting event is discussed in section 7.2.17 .
For the given URI reference event r and the statement with terms s , p and o corresponding to the N-Triples:
s
p
o
.
add the following statements to the graph:
r
.
string-value
<http://www.w3.org/1999/02/22-rdf-syntax-ns#subject>
s
.
r
.
string-value
<http://www.w3.org/1999/02/22-rdf-syntax-ns#predicate>
p
.
r
.
string-value
<http://www.w3.org/1999/02/22-rdf-syntax-ns#object>
o
.
r
.
string-value
<http://www.w3.org/1999/02/22-rdf-syntax-ns#type>
<http://www.w3.org/1999/02/22-rdf-syntax-ns#Statement>
.
For the given element e , create a new RDF URI Reference reference u := concat("http://www.w3.org/1999/02/22-rdf-syntax-ns#_", e . li-counter ), increment the e . li-counter property by 1 and return u .
deleted text:For the given element e , create a new RDF URI Reference u := concat("http://www.w3.org/1999/02/22-rdf-syntax-ns#_", e . bag-li-counter ), increment the e . bag-li-counter property by 1 and return u .
<h2> <a id="section-Serialising" name="section-Serialising"> 8 Serializing an RDF Graph to RDF/XML </a> </h2> <p> There are some RDF Graphs as defined in the RDF Concepts and Abstract Syntax deleted text: Working Draft. that cannot be serialized in RDF/XML. These are those that: </p> <dl> <dt> Use property names that cannot be turned into XML namespace-qualified names. <br /> </dt> <dd> An XML namespace-qualified name ( <a href="http://www.w3.org/TR/REC-xml-names/#dt-qname"> QName </a> ) has restrictions on the legal characters such that not all property URIs can be expressed as these names. It is recommended that implementors of RDF serializers, in order to break a URI into a namespace name and a local name, split it after the last XML non- <a href="http://www.w3.org/TR/REC-xml-names/#NT-NCName"> NCName </a> character, ensuring that the first character of the name is a <a href="http://www.w3.org/TR/REC-xml#NT-Letter"> Letter </a> or '_'. If the URI ends in a non- <a href="http://www.w3.org/TR/REC-xml-names/#NT-NCName"> NCName </a> character then throw a "this graph cannot be serialized in RDF/XML" exception or error. </dd> <dt> Use inappropriate reserved names as properties <br /> </dt> <dd> For example, a property with the same URI as any of the <a href="#syntaxTerms"> syntaxTerms </a> production. </dd> </dl>
A
more
detailed
discussion
of
the
issues
of
serializing
the
Implementation
Note
(Informative):
When
an
RDF
Graph
graph
is
serialized
to
RDF/XML
is
given
and
has
an
XML
Schema
Datatype
(XSD),
it
SHOULD
be
written
in
[UNPARSING]
.
This
describes
using
the
original
syntax
without
the
subsequently
added
rdf:nodeID
attribute
a
form
that
now
allows
all
graphs
with
blank
nodes
to
be
serialized.
does
not
require
whitespace
processing.
XSD
support
is
NOT
required
by
RDF
or
RDF/XML
so
this
is
optional.
If RDF/XML is embedded inside HTML or XHTML this can add many new elements and attributes, many of which will not be in the appropriate DTD. This embedding causes validation against the DTD to fail. The obvious solution of changing or extending the DTD is not practical for most uses. This problem has been analyzed extensively by Sean B. Palmer in RDF in HTML: Approaches deleted text: <a href="#ref-rdf-in-xhtml"> [RDF-IN-XHTML] </a> and it concludes that there is no single embedding method that satisfies all applications and remains simple. </p> <p> The recommended approach is to not embed RDF/XML in HTML/XHTML but rather to use <code> <link> </code> element in the <code> <head> </code> element of the HTML/HTML to point at a separate RDF/XML document. This approach has been used for several years by the Dublin Core Metadata Initiative (DCMI) on its Web site.
To
use
this
technique,
the
<link>
element
href
should
point
at
the
URI
of
the
RDF/XML
content
and
the
type
attribute
should
be
used
with
the
value
of
"application/rdf+xml"
,
the
proposed
MIME
Type
type
for
RDF/XML,
see
Section
4
The
value
of
the
rel
attribute
may
also
be
set
to
indicate
the
relationship;
this
is
an
application
dependent
value.
The
DCMI
has
used
and
recommended
rel="meta"
when
linking
in
RFC
2731
-
—
Encoding
Dublin
Core
Metadata
in
HTML
[RFC-2731]
however
rel="alternative"
rel="alternate"
may
also
be
appropriate.
See
HTML
4.01
link
types
and
,
XHTML
Modularization
-
—
LinkTypes
and
XHTML
2.0
—
LinkTypes
for
further
information.
information
on
the
values
that
may
be
appropriate
for
the
different
versions
of
HTML.
Example
21
shows
using
this
method
with
the
link
tag
inside
an
XHTML
document
to
link
to
an
external
RDF/XML
document.
link
in
XHTML
with
an
external
RDF/XML
document
(
example21.html
linking
to
example21.rdf
)
<?xml version="1.0" encoding='iso-8859-1'?> <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"> <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en"> <head> <title>My document</title> <meta http-equiv="Content-type" content='text/html; charset="iso-8859-1"' /> <link rel="alternate" type="application/rdf+xml" title="RDF Version" href="example21.rdf" /> </head> <body> <h1>My document</h1> </body> </html>
There is a standardized approach for associating RDF compatible metadata with SVG — the metadata element which was explicitly designed for this purpose as defined in Section 21 Metadata of the Scalable Vector Graphics (SVG) 1.0 Specification [SVG] and Section 21 Metadata of the Scalable Vector Graphics (SVG) 1.1 Specification [SVG11] .
This document contains two example graphs in SVG with such embedded RDF/XML inside the metadata element: figure 1 and figure 2 .
The following people provided valuable contributions to the document:
This document is a product of extended deliberations by the RDF Core working group, whose members have included: Art Barstow (W3C) Dave Beckett (ILRT), Dan Brickley (W3C/ILRT), Dan Connolly (W3C), Jeremy Carroll (Hewlett Packard), Ron Daniel (Interwoven Inc), Bill dehOra (InterX), Jos De Roo (AGFA), Jan Grant (ILRT), Graham Klyne (Clearswift and Nine by Nine), Frank Manola (MITRE Corporation), Brian McBride (Hewlett Packard), Eric Miller (W3C), Stephen Petschulat (IBM), Patrick Stickler (Nokia), Aaron Swartz (HWG), Mike Dean (BBN Technologies / Verizon), R. V. Guha (Alpiri Inc), Pat Hayes (IHMC), Sergey Melnik (Stanford University), Martyn Horner (Profium Ltd).
This specification also draws upon an earlier RDF Model and Syntax document edited by Ora Lassilla and Ralph Swick, and RDF Schema edited by Dan Brickley and R. V. Guha. RDF and RDF Schema Working group members who contributed to this earlier work are: Nick Arnett (Verity), Tim Berners-Lee (W3C), Tim Bray (Textuality), Dan Brickley (ILRT / University of Bristol), Walter Chang (Adobe), Sailesh Chutani (Oracle), Dan Connolly (W3C), Ron Daniel (DATAFUSION), Charles Frankston (Microsoft), Patrick Gannon (CommerceNet), RV Guha (Epinions, previously of Netscape Communications), Tom Hill (Apple Computer), Arthur van Hoff (Marimba), Renato Iannella (DSTC), Sandeep Jain (Oracle), Kevin Jones, (InterMind), Emiko Kezuka (Digital Vision Laboratories), Joe Lapp (webMethods Inc.), Ora Lassila (Nokia Research Center), Andrew Layman (Microsoft), Ralph LeVan (OCLC), John McCarthy (Lawrence Berkeley National Laboratory), Chris McConnell (Microsoft), Murray Maloney (Grif), Michael Mealling (Network Solutions), Norbert Mikula (DataChannel), Eric Miller (OCLC), Jim Miller (W3C, emeritus), Frank Olken (Lawrence Berkeley National Laboratory), Jean Paoli (Microsoft), Sri Raghavan (Digital/Compaq), Lisa Rein (webMethods Inc.), Paul Resnick (University of Michigan), Bill Roberts (KnowledgeCite), Tsuyoshi Sakata (Digital Vision Laboratories), Bob Schloss (IBM), Leon Shklar (Pencom Web Works), David Singer (IBM), Wei (William) Song (SISU), Neel Sundaresan (IBM), Ralph Swick (W3C), Naohiko Uramoto (IBM), Charles Wicksteed (Reuters Ltd.), Misha Wolf (Reuters Ltd.), Lauren Wood (SoftQuad).
This appendix contains XML schemas for validating RDF/XML forms. These are example schemas for information only and are not part of this specification.
This is an example schema in RELAX NG Compact (for ease of reading) for RDF/XML. Applications can also use the RELAX NG XML version . These formats are described in RELAX NG ( [RELAXNG] ) and RELAX NG Compact ( [RELAXNG-COMPACT] ).
Note: The RNGC schema has been updated to attempt to match the grammar but this has not been checked or used to validate RDF/XML.
# # RELAX NG Compact Schema for RDF/XML Syntax # # This schema is for information only and NON-NORMATIVE # # It is based on one originally written by James Clark in # http://lists.w3.org/Archives/Public/www-rdf-comments/2001JulSep/0248.html # and updated with later changes. # namespace local = "" namespace rdf = "http://www.w3.org/1999/02/22-rdf-syntax-ns#" datatypes xsd = "http://www.w3.org/2001/XMLSchema-datatypes" start = doc # I cannot seem to do this in RNGC so they are expanded in-line # coreSyntaxTerms = rdf:RDF | rdf:ID | rdf:about | rdf:bagID | rdf:parseType | rdf:resource | rdf:nodeID | rdf:datatype # coreSyntaxTerms = rdf:RDF | rdf:ID | rdf:about | rdf:parseType | rdf:resource | rdf:nodeID | rdf:datatype # syntaxTerms = coreSyntaxTerms | rdf:Description | rdf:li # oldTerms = rdf:aboutEach | rdf:aboutEachPrefix # oldTerms = rdf:aboutEach | rdf:aboutEachPrefix | rdf:bagID # nodeElementURIs = * - ( coreSyntaxTerms | rdf:li | oldTerms ) # propertyElementURIs = * - ( coreSyntaxTerms | rdf:Description | oldTerms ) # propertyAttributeURIs = * - ( coreSyntaxTerms | rdf:Description | rdf:li | oldTerms ) # Also needed to allow rdf:li on all property element productions # since we can't capture the rdf:li rewriting to rdf_<n> in relaxng # Need to add these explicitly xmllang = attribute xml:lang { text } xmlbase = attribute xml:base { text } # and to forbid every other xml:* attribute, element doc = RDF RDF | nodeElement RDF = element rdf:RDF { xmllang?, xmlbase?, nodeElementList } nodeElementList = nodeElement* # Should be something like: # ws* , ( nodeElement , ws* )* # but RELAXNG does this by default, ignoring whitespace separating tags. nodeElement = element * - ( rdf:RDF | rdf:ID | rdf:about | rdf:bagID | rdf:parseType | element * - ( local:* | rdf:RDF | rdf:ID | rdf:about | rdf:parseType | rdf:resource | rdf:nodeID | rdf:datatype | rdf:li | rdf:aboutEach | rdf:aboutEachPrefix | xml:* ) { (idAttr | nodeIdAttr | aboutAttr )?, bagIdAttr?, xmllang?, xmlbase?, propertyAttr*, propertyEltList rdf:aboutEach | rdf:aboutEachPrefix | rdf:bagID ) { (idAttr | nodeIdAttr | aboutAttr )?, xmllang?, xmlbase?, propertyAttr*, propertyEltList } # It is not possible to say "and not things # beginning with _ in the rdf: namespace" in RELAX NG. ws = " " # Not used in this RELAX NG schema; but should be any legal XML # whitespace defined by http://www.w3.org/TR/2000/REC-xml-20001006#NT-S propertyEltList = propertyElt* # Should be something like: # ws* , ( propertyElt , ws* )* # but RELAXNG does this by default, ignoring whitespace separating tags. propertyElt = resourcePropertyElt | literalPropertyElt | parseTypeLiteralPropertyElt | parseTypeResourcePropertyElt | parseTypeCollectionPropertyElt | parseTypeOtherPropertyElt | emptyPropertyElt resourcePropertyElt = element * - ( rdf:RDF | rdf:ID | rdf:about | rdf:bagID | rdf:parseType | element * - ( local:* | rdf:RDF | rdf:ID | rdf:about | rdf:parseType | rdf:resource | rdf:nodeID | rdf:datatype | rdf:Description | rdf:aboutEach | rdf:aboutEachPrefix | rdf:Description | rdf:aboutEach | rdf:aboutEachPrefix | rdf:bagID | xml:* ) { idAttr?, xmllang?, xmlbase?, nodeElement } literalPropertyElt = element * - ( rdf:RDF | rdf:ID | rdf:about | rdf:bagID | rdf:parseType | element * - ( local:* | rdf:RDF | rdf:ID | rdf:about | rdf:parseType | rdf:resource | rdf:nodeID | rdf:datatype | rdf:Description | rdf:aboutEach | rdf:aboutEachPrefix | xml:* ) { rdf:Description | rdf:aboutEach | rdf:aboutEachPrefix | rdf:bagID | xml:* ) { (idAttr | datatypeAttr )?, xmllang?, xmlbase?, text } parseTypeLiteralPropertyElt = element * - ( rdf:RDF | rdf:ID | rdf:about | rdf:bagID | rdf:parseType | element * - ( local:* | rdf:RDF | rdf:ID | rdf:about | rdf:parseType | rdf:resource | rdf:nodeID | rdf:datatype | rdf:Description | rdf:aboutEach | rdf:aboutEachPrefix | rdf:Description | rdf:aboutEach | rdf:aboutEachPrefix | rdf:bagID | xml:* ) { idAttr?, parseLiteral, xmllang?, xmlbase?, literal } parseTypeResourcePropertyElt = element * - ( rdf:RDF | rdf:ID | rdf:about | rdf:bagID | rdf:parseType | element * - ( local:* | rdf:RDF | rdf:ID | rdf:about | rdf:parseType | rdf:resource | rdf:nodeID | rdf:datatype | rdf:Description | rdf:aboutEach | rdf:aboutEachPrefix | rdf:Description | rdf:aboutEach | rdf:aboutEachPrefix | rdf:bagID | xml:* ) { idAttr?, parseResource, xmllang?, xmlbase?, propertyEltList } parseTypeCollectionPropertyElt = element * - ( rdf:RDF | rdf:ID | rdf:about | rdf:bagID | rdf:parseType | element * - ( local:* | rdf:RDF | rdf:ID | rdf:about | rdf:parseType | rdf:resource | rdf:nodeID | rdf:datatype | rdf:Description | rdf:aboutEach | rdf:aboutEachPrefix ) { rdf:Description | rdf:aboutEach | rdf:aboutEachPrefix | rdf:bagID | xml:* ) { idAttr?, xmllang?, xmlbase?, parseCollection, nodeElementList } parseTypeOtherPropertyElt = element * - ( rdf:RDF | rdf:ID | rdf:about | rdf:bagID | rdf:parseType | element * - ( local:* | rdf:RDF | rdf:ID | rdf:about | rdf:parseType | rdf:resource | rdf:nodeID | rdf:datatype | rdf:Description | rdf:aboutEach | rdf:aboutEachPrefix | rdf:Description | rdf:aboutEach | rdf:aboutEachPrefix | rdf:bagID | xml:* ) { idAttr?, xmllang?, xmlbase?, parseOther, any } emptyPropertyElt = element * - ( rdf:RDF | rdf:ID | rdf:about | rdf:bagID | rdf:parseType | element * - ( local:* | rdf:RDF | rdf:ID | rdf:about | rdf:parseType | rdf:resource | rdf:nodeID | rdf:datatype | rdf:Description | rdf:aboutEach | rdf:aboutEachPrefix | rdf:Description | rdf:aboutEach | rdf:aboutEachPrefix | rdf:bagID | xml:* ) { idAttr?, (resourceAttr | nodeIdAttr)?, bagIdAttr?, xmllang?, xmlbase?, propertyAttr* idAttr?, (resourceAttr | nodeIdAttr)?, xmllang?, xmlbase?, propertyAttr* } idAttr = attribute rdf:ID { IDsymbol } nodeIdAttr = attribute rdf:nodeID { IDsymbol } aboutAttr = attribute rdf:about { URI-reference } deleted text: bagIdAttr = attribute rdf:bagID { IDsymbol } propertyAttr = attribute * - ( rdf:RDF | rdf:ID | rdf:about | rdf:bagID | rdf:parseType | attribute * - ( local:* | rdf:RDF | rdf:ID | rdf:about | rdf:parseType | rdf:resource | rdf:nodeID | rdf:datatype | rdf:li | rdf:Description | rdf:aboutEach | rdf:aboutEachPrefix | xml:* ) { rdf:aboutEachPrefix | rdf:bagID | xml:* ) { string } resourceAttr = attribute rdf:resource { URI-reference } datatypeAttr = attribute rdf:datatype { URI-reference } parseLiteral = attribute rdf:parseType { "Literal" } parseResource = attribute rdf:parseType { "Resource" } parseCollection = attribute rdf:parseType { "Collection" } parseOther = attribute rdf:parseType { text } URI-reference = string literal = any IDsymbol = xsd:NMTOKEN any = mixed { element * { attribute * { text }*, any }* }
Changes since between the 8 November 2002 23 January 2003 last call working draft and 05 September 2003 working draft
(Newest at top) These are are divided into non-editorial and editorial. The non-editorial changes also list consquential editorial changes. Editorial changes are those which do not result in any change in the meaning of an RDF document or the behaviour of an RDF application.
rdf:bagID
being
permitted.
Section
2.17
Reifying
Statements
changed
title,
removed
rdf:bagID
discussion
and
Example
21.
Section
3
Terminology
removed
bagID
from
syntax
names.
Section
5.2
Identifiers
Blank
nodeIDs
in
RDF/XML
are
scoped
removed
bagID
from
discussion
of
URI
references.
Section
5.4
Constraints
removed
bagID
from
constraint-id
.
Section
6.1.2
Element
Event
removed
bag-id-counter
accessor.
Section
6.1.4
Attribute
Event
removed
bagID
from
allowed
non-namespaced
attributes.
7.2.2
Production
coreSyntaxTerms
removed
rdf:bagID
.
7.2.4
Production
oldTerms
added
rdf:bagID
and
link
to
the
infoset
document
infoitem.
rdf:parseType="Collection"
after
the
complex
examples
rdf:XMLLiteral
as
approved
in
RDF
Core
telcon
2003-05-09.
Also
added
N-Triples
escapes
for
URI
references
to
normative
references.
rdf:nodeID
rdf:parseType="Literal"
content
using
Exclusive
XML
Canonicalization.
A
clarification
after
it
was
noticed
the
output
of
exc-C14N
was
an
sequence
of
octets
not
a
Unicode
string.
xml:base
or
the
URI
of
the
document.
7.2.19
Production
parseTypeCollectionPropertyElt
Minor
words.
rdf:parseType="Resource"
reworded
to
clarify
which
property
element
was
discussed.
2.12
Omitting
Nodes:
Property
Attributes
on
an
empty
Property
Element
reworded
to
explain
moving
the
property
element
to
a
property
attribute
2.15
Container
Membership
Property
Elements:
rdf:li
and
rdf:_
n
added
note
that
document
order
matters
here.
2.16
Collections:
rdf:parseType="Collection"
added
note
that
document
order
matters
here.
After
comments
in
personal
communication
to
the
editor
2003-06-17.
rdf:bagID
was
removed
from
the
language
for
last
call
issue
timbl-01
,
this
comment
by
Krech
required
no
action.
Changes since the terms 05 September 2003 working draft
These are are divided into non-editorial and editorial. The non-editorial changes also list consquential editorial changes. Editorial changes are those which do not result in any change in the meaning of an RDF Concepts.
rdfs:XMLLiteral
rdf:RDF
with
made
optional
rdf:XMLLiteral
rdf:RDF
element
was
made
optional
when
there
is
only
one
outer
node
element
(inside
rdf:RDF
)
in
5.1
an
RDF/XML
document.
Changed
7.2.1
Grammar
start
to
allow
this
and
updated
2.6
Completing
the
Document:
Document
Element
and
XML
Declaration
to
mention
this
option.
Amended
the
informative
RELAX NG
schema
to
match.
Change
made
after
comment
from
Mark
Baker
2003-09-25
as
approved
at
RDF
Namespace
Core
WG
telcon
2003-10-03
.
Previous changes are listed in and 7.2.21 emptyPropertyElt from the changes section proposal 2003-09-18 and revised proposal 2003-10-03 after the original comment by Patel-Schneider 2003-08-07 as approved by RDF Core WG Telcon 2003-10-03