3.1 Triples

RDF allows us to make statements about resources. The format of these statements is simple. It always has the following form:

      <subject>  <predicate> <object>
    

An RDF statement represents a relationship between two resources. The subject and the object represent the two resources being related; the predicate represents the nature of their relationship. The relationship is phrased in a directional way (from subject to object) and is called in RDF a property. Because RDF statements consist of three elements they are called triples.

Informally speaking, RDF allows us to make statements of the form:

<Bob> <is a> <person>.
<Bob> <is a friend of> <Alice>.
<Bob> <is born on> <the 4th of July 1990>. 
<Bob> <is interested in> <the Mona Lisa>.
<The Mona Lisa> <was created by> <Leonardo da Vinci>.
<The video 'La Joconde à Washington'> <is about> <the Mona Lisa>

Resources typically occur in multiple triples, for example Bob and the Mona Lisa painting in the examples above. We can therefore visualise triples as a connected graph. Graphs consists of nodes and arcs. The subjects and objects of the triples make up the nodes in the graph; the predicates form the arcs. Fig. 1 shows the graph resulting from the sample triples.

The example above does not constitute actual RDF syntax; it is just intended to provide an informal view of the notion of an RDF graph.

In the next three subsections we discuss the three types of RDF data that occur in triples: IRIs, literals and blank nodes.

3.2 IRIs

The abbreviation IRI is short for "International Resource Identifier". An IRI identifies a Web resource. The notion of IRI is a generalization of URI (Uniform Resource Identifier), allowing non-ASCII characters to be used in the IRI character string. IRIs are specified in RFC 3987 [RFC3987].

IRIs can appear in all three positions of a triple.

IRIs can be used to identify both documents (e.g. a Web page) and things (e.g. a person). For example, the IRI for the "Mona Lisa" painting in Wikidata is:

The IRI for Leonardo da Vinci in DBpedia is:

The IRI for an INA video about the Mona Lisa entitled 'La Joconde à Washington' in Europeana is:

3.3 Literals

Literals are basic values that are not IRIs. Examples of literals include strings such as "La Joconde", dates such as "the 4th of July, 1990" and numbers such as "3.14159". Literals are associated with a datatype enabling such values to be parsed and interpreted correctly. String literals can optionally be associated with a language tag. For example "Léonard de Vinci" could be associated with the "fr" language tag and "李奥纳多·达·文西" with the "zh" language tag.

Literals may only appear in the object position of a triple.

The RDF Concepts document provides a (non-exhaustive) list of datatypes. This includes many datatypes defined by XML Schema, such as string, boolean, integer, decimal and date.

3.4 Blank nodes

IRIs and literals together provide the basic material for writing down RDF statements. In addition, it is sometimes handy to be able to talk about resources without bothering to use an identifier. For example, we might want to state that the Mona Lisa painting has in its background an unidentified tree which we know to be a cypress tree. Resources such as the unidentified cypress tree are called "blank nodes" in RDF. A blank node indicates an un-named thing. Blank nodes are like simple variables in algebra; they represent some thing without saying what their value is.

Blank nodes can appear in the subject and object position of a triple. They can be used to denote resources without explicitly naming them with an IRI.

3.5 Multiple graphs

RDF provides a mechanism to group RDF statements in multiple graphs and associate each graph with an IRI. Multiple graphs in an RDF document constitute an RDF dataset. An RDF dataset may have multiple named graphs and at most one default graph (i.e. a graph without a name).

For example, the statements in the first example could be grouped in two named graphs. A first graph could be provided by a social networking site and identified by http://example.org/bob:

        <Bob> <is a> <person>.
        <Bob> <is a friend of> <Alice>.
        <Bob> <is born on> <the 4th of July 1990>.
        <Bob> <is interested in> <the Mona Lisa>.
      

A second graph could be provided by Wikidata and identified by https://www.wikidata.org/wiki/Special:EntityData/Q12418:

        <Leonardo da Vinci> <is the creator of> <the Mona Lisa>.
        <The video 'La Joconde à Washington'> <is about> <the Mona Lisa>
      

In the example default (unnamed) graph below we see two triples that have a graph name as subject:

        <http://example.org/bob> <is published by> <http://example.org>.
        <http://example.org/bob> <has license> <http://creativecommons.org/licenses/by/3.0/>.
      

RDF 1.1 doesn't prescribe any specific semantics for datasets. Possible semantics are described in a separate note [RDF11-DATASETS]. In this example dataset we assume graph names represent the source of the RDF data held within the corresponding graphs, i.e. by retrieving <http://example.org/bob> we would get access to the four triples in that graph. In the example default graph we associate provenance information (publisher, license) with the <http://example.org/bob> graph.

Sec. 5.2 provides an example of concrete syntax for this example.

5.1 Turtle

Turtle [TURTLE] provides a syntax for RDF graphs, which is relatively convenient for humans. Turtle introduces a number of syntax shortcuts, such as support for namespaces, lists and shorthands for datatyped literals. Turtle provides a trade-off between ease of writing, ease of parsing and readability. Our first example (in slightly extended form) can be represented in Turtle as follows:

01    BASE   <http://example.org/>
02    PREFIX foaf: <http://xmlns.com/foaf/0.1/>
03    PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>
04    PREFIX schema: <http://schema.org/>
05    PREFIX dcterms: <http://purl.org/dc/terms/>
06    PREFIX wd: <http://www.wikidata.org/entity/>
07 
08    <bob#me>
09        a foaf:Person ;
10        foaf:knows <alice#me> ;
11        schema:birthDate "1990-07-04"^^xsd:date ;
12        foaf:topic_interest wd:Q12418 .
13
14    wd:Q12418
15        dcterms:title "Mona Lisa" ;
16        dcterms:creator <http://dbpedia.org/resource/Leonardo_da_Vinci> .
17
18    <http://data.europeana.eu/item/04802/243FA8618938F4117025F17A8B813C5F9AA4D619>
19        dcterms:subject wd:Q12418 .

Lines 1-6 contain a number of directives which provide shorthands for writing down IRIs. In Turtle IRIs are enclosed in angle brackets (<>). Relative IRIs (such as bob#me on line 8) are resolved agains a base IRI, specified here in line 1. Lines 2-6 define IRI prefixes (such as foaf:), which can be use for prefixed names (such as foaf:Person) instead of full IRIs. The corresponding IRI is constructed by replacing the prefix with its corresponding IRI (in this example foaf:Person stands for <http://xmlns.com/foaf/0.1/Person>).

Lines 8-12 show how Turtle provides a shorthand for a set of triples with the same subject. Lines 9-12 specify the predicate-object part of triples with <http://example.org/bob#me> as subject. The semicolons at the end of lines 9-11 indicate that the set is not yet complete. A period is used to signal the end of a Turtle statement.

The triple represented by line 10 looks in its expanded form like this (see the N-Triples example for the expanded form of the full example):

<http://example.org/bob#me> <http://xmlns.com/foaf/0.1/knows> <http://example.org/alice#me> .

Line 9 shows an example of a special kind of syntactic sugar. The triple should informally be read as "Bob (is) a Person". The a predicate is a shorthand for the property rdf:type which models the instance relation (see Table "RDF Schema constructs"). The a shorthand is intended to match the human intuition about rdf:type.

In line 11 we see an example of a literal, in this case a date. The datatype is appended to the literal through a ^^ delimiter. The date representation follows the conventions of the XML Schema datatype date.

Because string literals are so ubiquitous Turtle allows the user to omit the datatype when writing a string literal. Thus, "Mona Lisa" in line 15 is equivalent to "Mona Lisa"^^xsd:string.

The figure below shows the triples resulting from this example.

In case of language-tagged strings the tag appears directly after the string, separated by a @ symbol, e.g. "La Joconde"@fr (the French name of the Mona Lisa).

Below is sample Turtle syntax for blank nodes, using the earlier cypress-tree example:

PREFIX lio: <http://purl.org/net/lio#> 

<http://dbpedia.org/resource/Mona_Lisa> lio:shows _:x .
_:x a <http://dbpedia.org/resource/Cypress> .

The term _:x is a blank node. It represents some unnamed tree depicted in the Mona Lisa painting and belonging to the "Cypress" class.

The above is by no means a full account of the Turtle syntax. For more details about the syntax of Turtle the reader is referred to the Turtle document [TURTLE].

5.2 TriG

The syntax of Turtle supports only the specification of single graphs without a means for "naming" them. TriG [TRIG] is an extension to the Turtle syntax enabling the specification of multiple graphs.

The multiple-graphs version of our example can be specified in TriG as follows:

01    BASE   <http://example.org/> 
02    PREFIX foaf: <http://xmlns.com/foaf/0.1/> 
03    PREFIX xsd: <http://www.w3.org/2001/XMLSchema#> 
04    PREFIX schema: <http://schema.org/> 
05    PREFIX dcterms: <http://purl.org/dc/terms/> 
06    PREFIX wd: <http://www.wikidata.org/entity/> 
07    
08    GRAPH <http://example.org/bob>
09      {
10        <bob#me>
11            a foaf:Person ;
12            foaf:knows <alice#me> ;
13            schema:birthDate "1990-07-04"^^xsd:date ;
14            foaf:topic_interest wd:Q12418 .
15      }
16
17    GRAPH <https://www.wikidata.org/wiki/Special:EntityData/Q12418>
18      {
19        wd:Q12418
20            dcterms:title "Mona Lisa" ;
21            dcterms:creator <http://dbpedia.org/resource/Leonardo_da_Vinci> .
22    
23        <http://data.europeana.eu/item/04802/243FA8618938F4117025F17A8B813C5F9AA4D619>
24           dcterms:subject wd:Q12418 .
25      }
26
27    <http://example.org/bob>
28        dcterms:publisher <http://example.org> ;
29        dcterms:rights <http://creativecommons.org/licenses/by/3.0/> .

This RDF dataset contains two named graphs. Lines 8 and 16 list the names of these two graphs. The triples in the named graph are placed in between matching curly braces (lines 9 & 15, 18 & 28). Optionally you can precede the graph name with the keyword GRAPH. This may improve readability, but it is mainly introduced for alignment with SPARQL Update [SPARQL11-OVERVIEW].

The syntax of the triples and of the directives at the top conforms to the Turtle syntax.

The two triples specified on lines 30-32 are not part of any named graph. Together they form the default graph of this RDF dataset.

The figure below shows the triples resulting from this example.

5.3 Other concrete syntaxes for RDF

Next to Turtle/TriG there are a number of other concrete syntaxes for RDF data. These syntaxes were developed to cater for specific application and/or usage needs. The examples given for each of these syntaxes correspond to the same graph (i.e., the same set of triples) as the Turtle example (in the case of a single graph, see Fig. 2)or the TriG example (in the case of multiple graphs, see Fig. 3).

RDFa

RDFa [RDFA-PRIMER] (single-graph example) can be used to embed RDF data within HTML documents. This enables, for example, search engines to aggregate this data when crawling the web and use it to enrich search results (see, e.g., schema.org and Rich Snippets).

JSON-LD

JSON-LD [JSON-LD] (single-graph example, multiple-graphs example) provides a JSON syntax for RDF graphs and datasets. JSON-LD can be used to transform JSON documents to RDF with minimal changes. JSON-LD offers universal identifiers for JSON objects, a mechanism in which a JSON document can refer to an object described in another JSON document elsewhere on the Web, as well as datatype and language handling. JSON-LD also provides a way to serialize RDF datasets through the use of the @graph keyword.

N-Triples

N-Triples [N-TRIPLES] ( single-graph example) provides a simple line-based, plain text way for serializing RDF graphs. Each line represents an RDF triple. Its subject, predicate and object are separated by white space. N-Triples is often used for RDF examples, exchanging large RDF datasets, and processing large RDF graphs with line-oriented text processing tools.

N-Quads

N-Quads [N-QUADS] (multiple-graphs example) is a simple extension to N-Triples enabling the exchange of RDF datasets. N-Quads adds a fourth element to each line, capturing the graph IRI of the triple described on that line.

RDF/XML

RDF/XML [RDF-SYNTAX-GRAMMAR] (single-graph example) provides an XML syntax for RDF graphs. RDF/XML was the only normative syntax for RDF when RDF 1.0 was published in 2004.

For more information about these syntaxes consult the references.