# RDF 1.1: Knowledge Representation and Data Integration Language for the Web

Dominik Tomaszuk, and David Hyland-Wood

###### Abstract

Resource Description Framework (RDF) can seen as a solution in today’s
landscape of knowledge representation research. An RDF language has
symmetrical features because subjects and objects in triples can be
interchangeably used. Moreover, the regularity and symmetry of the RDF
language allow knowledge representation that is easily processed by machines,
and because its structure is similar to natural languages, it is reasonably
readable for people. RDF provides some useful features for generalized
knowledge representation. Its distributed nature, due to its identifier
grounding in IRIs, naturally scales to the size of the Web. However, its use
is often hidden from view and is, therefore, one of the less well-known of the
knowledge representation frameworks. Therefore, we summarise RDF v1.0 and v1.1
to broaden its audience within the knowledge representation community. This
article reviews current approaches, tools, and applications for mapping from
relational databases to RDF and from XML to RDF. We discuss RDF
serializations, including formats with support for multiple graphs and we
analyze RDF compression proposals. Finally, we present a summarized formal
definition of RDF 1.1 that provides additional insights into the modeling of
reification, blank nodes, and entailments.

Submitted to Symmetry https://doi.org/10.3390/sym12010084

##  1 Introduction

The Resource Description Framework version 1.1 is a modern and complete
knowledge representation framework that is seemingly underrepresented within
the traditional knowledge representation research community. We seek to
clarify some differences between the way RDF 1.1 was defined in World Wide Web
Consortium (W3C) specifications and the ways in which it is reinterpreted
during implementation. Firstly, we need to discuss how RDF relates to the
broader field of knowledge representation.

Knowledge representation can be seen as the way in which knowledge is
presented in a language. More precisely it was clarified by Sowa [138], who
presents five characteristics of knowledge representation:

  1. 1.

It is most fundamentally a surrogate.

  2. 2.

It is a collection of ontological commitments.

  3. 3.

It is a fragmental intelligent reasoning theory.

  4. 4.

It is a pragmatically efficient computation medium.

  5. 5.

It is a human expression medium.

Natural language can be defined as one of the methods of knowledge
representation. The fundamental unit of knowledge in such languages is often a
sentence that consists of a set of words arranged according to grammatical
rules. In spite of the existence of grammatical rules that encode expectations
of word order, irregularities and exceptions to the rules make it difficult
for machines to process natural languages.

The RDF data model was a response to this problem for knowledge representation
on the World Wide Web. This language and the notions from which it originates
have enabled free data exchange, formalization, and unification of stored
knowledge. RDF was developed iteratively over nearly two decades to address
knowledge representation problems at Apple Computer, Netscape Communications
Corporation, and the Semantic Web and Linked Data projects at the World Wide
Web Consortium.

An assumption in RDF [123] is to define resources by means of the statement
consisting of three elements (the so-called RDF _triple_): _subject_ ,
_predicate_ , and _object_. RDF borrows strongly from natural languages. An
RDF _triple_ may then be seen as an expression with _subject_ corresponding to
the subject of a sentence, _predicate_ corresponding to its verb and _object_
corresponding to its object [130]. So the RDF language may be categorized into
the same syntactic criteria as natural languages. According to these premises,
RDF belongs to the group of Subject Verb Object languages (SVO) [44]. The
consistency and symmetry of the RDF language allows knowledge representation
that is easily processed by machines, and because its structure is similar to
that of natural languages, it is reasonably readable for people.

On the other hand, following Lenzerini [100], data integration is the issue of
joining data stored at disparate sources, and providing the user with an
integrated perspective of these data. Much of the data on the Web is stored in
relational databases. A similar amount of data exists in hierarchical files
such as XML documents. Integration of all of this data would provide huge
profits to the organizations, enterprises, and governments that own the data.

Interoperability is the capability of two or more (different) software systems
or their components to interchange information and to use the information that
has been shared [36]. In the context of the Web, interoperability is concerned
with the support of applications that exchange and share information across
the boundaries of existing data sources. The RDF world is a satisfying method
for organizing information from different information sources. In particular,
RDF can be seen as a general proposition language for the Web, which
consolidates data from heterogeneous sources. It can provide interoperability
between applications that exchange the data.

Knowledge representation and data integration in the context of RDF is
relevant for several reasons, including: promotes data exchange and
interoperability; facilitates the reuse of available systems and tools;
enables a fair comparison of Web systems by using benchmarks. In particular,
this article shows how the RDF data model can be related to other models.

The RDF language enables large portions of existing data to be processed and
analyzed. This produces the need to develop the foundations of this language.
This article addresses this challenge by developing an abstract model that is
suitable to formalize and explain properties about the RDF data. We study the
RDF data model, minimal and maximal representations, and show complexity
bounds for the main problems.

###  1.1 Contributions

When we examine the state of the RDF data model, we see evidence of trade-offs
that occurred as various constituencies took part in the design process. Many
of these trade-offs were never completely summarized in the RDF standards. Our
article reviews a final state of RDF, and to identify areas where this data
model is poorly understood. Our contributions are:

  1. 1.

to compare the RDF reification approaches,

  2. 2.

to analyze the RDF 1.1 interpretations, entailments and their complexity,

  3. 3.

to study the RDF blank nodes and their complexity,

  4. 4.

to compare the various RDF data integration approaches,

  5. 5.

to compare the RDF 1.1 serialization formats, including multiple graph
syntaxes,

  6. 6.

to compare the RDF binary and compression formats.

In addition, one of our main aims is to isolate a core fragment of RDF which
is the point of a formal analysis. We discuss a formalization of an RDF syntax
and semantics, which is beneficial, for example, to help identify
relationships among the constructors, to assist in optimization and
validations of software implementations, and to identify redundant notions.

###  1.2 Review Organization

The remainder of this article is as follows: Section 2 presents related work
and formalized concepts for RDF. In Section 3 we discuss RDF blank nodes and
their complexity. Section 4 analyzes a semantics for the RDF and, outlines a
set of different entailment regimes. Section 5 overviews and compares various
proposals for RDF data integration. Section 6 briefly introduces and compares
various serialization formats for RDF 1.1. In Section 7 we overview and
compare various proposals for RDF compression. Finally, Section 8 gives some
concluding remarks.

##  2 Literature Review

In this Section, we present chronologically related works, and show a
formalized syntax and concept for RDF.

The pre-version of RDF was published in 1999 [97]. In this document RDF did
not have many features known from current versions, e.g. there were no
explicit blank nodes. One of the first paper is published in 2000 [54], which
present RDF and RDFS. In 2001 Champin [37] focuses on RDF model and XML syntax
of RDF. In [31] Carroll provides a formal analysis of comparing RDF graphs. An
author proves that isomorphism of an RDF graph can be reduced to known graph
isomorphism problems. In [114], the authors focus on delineating RDFS(FA)
semantics for RDF Schema, which can interoperate with common first-order
languages. Grau [75] continues RDF(FA) approach and proposes a possible
simplification of the Semantic Web architecture. Yang et al. [163] propose a
semantics for anonymous resources and statements in F-logic [93]. Another
overview is presented in [12] by Berners-Lee and in [105] by Marin.

The RDF 1.0 recommendation [104] has been reviewed of several analyzes. In
2004 Gutierrez et al. [78] formalized RDF and investigate computational
aspects of testing entailment and redundancy. In 2005, in [50, 69], the
authors propose a logical reconstruction of the RDF family languages.
Feigenbaum [61] briefly describes RDF with emphasis on the Semantic Web. In
[107, 108], the authors discuss fragments of RDF and systematize them. These
papers also outline complexity bound for ground entailment in the proposed
fragment. Yet another approach is provided in [118], which presents domain-
restricted RDF (dRDF). In 2011 and 2012 another descriptions are shown in [85]
and [4], which presents Semantic Web technologies. In 2014 Curé et al. [45]
briefly introduce RDF 1.0 and RDFS 1.0. There are also a lot of papers that
extend to RDF annotations [165, 26, 155] e.g. for fuzzy metrics [144],
temporal metrics [77], spatial metrics [96] and trust metrics [153]. A
separate group are publications on data integration in the context of RDF
[134, 139, 81, 147]. The term relational database to RDF mapping has been used
in [139]. In [134, 147] the authors propose direct mappings, and in [81]
indirect mappings is presented.

In order for machines to exchange machine-readable data, they need to agree
upon a universal data model under which to structure, represent and store
content. This data model should be general enough to provide representation
for arbitrary data content regardless of its structure. The data model should
also enable the processing of this content. The core data model selected, for
use on the Semantic Web and Web of Data digital ecosystems is RDF.

RDF constitutes a common method of the conceptual description or information
modeling accessible in Web resources. It provides the crucial foundation and
framework to support the description and management of data. Especially, RDF
is a general data model for resources and relationship descriptions between
them.

The RDF data model rests on the concept of creating web-resource statements in
the form of subject-predicate-object expressions, which in the RDF
terminology, are referred to as _triples_.

An RDF triple consists of a subject, a predicate, and an object. In [47], the
meaning of subject, predicate and object is clarified. The _subject_ expresses
a resource, the _object_ fills the value of the relation, the _predicate_
refers to the features or aspects of resource and expresses a subject-object
relationship. The predicate indicates a binary relation, also known as a
property.

Following [47], we provide definitions of RDF triples below.

######  Definition 2.1 (RDF triple).

Assume that $\mathcal{I}$ is the set of all Internationalized Resource
Identifiers (IRIs), $\mathcal{B}$ (an infinite) set of blank nodes,
$\mathcal{L}$ the set of literals. An _RDF triple_ is defined as a triple
$t=\langle s,p,o\rangle$ where $s\in\mathcal{I}\cup\mathcal{B}$ is called the
_subject_ , $p\in\mathcal{I}$ is called the _predicate_ and
$o\in\mathcal{I}\cup\mathcal{B}\cup\mathcal{L}$ is called the _object_.∎

######  Example 2.1.

The example presents an RDF triple consisting of subject, predicate and
object.

    <http://example.com/me#john>   foaf:firstName   "John" .

The primitive constituents of the RDF data model are terms that can be
utilized in reference to resources: anything with identity. The set of the
terms is divided into three disjoint subsets:

  * •

IRIs,

  * •

blank nodes,

  * •

literals.

######  Definition 2.2 (IRIs).

_IRIs_ are a set of Unicode names in registered namespaces and addresses
referring to registered protocols or namespaces used to identify a web
resource. For example, <http://dbpe
dia.org/resource/House> is used to identify the house in DBpedia [7].∎

Note that in RDF 1.0 identifiers were RDF URI (Uniform Resource Identifier)
References. Identifiers in RDF 1.1 are now IRIs, which are URIs
generalization, which allows a wider range of Unicode codes. Please notice
that each absolute URL (and URI) is an Internationalized Resource Identifier,
but not every IRI is a URI. When one is implemented in operations that are
exclusively specified for URI, it should first be transformed.

IRIs can be shortened. RDF syntaxes use two similar ways: CURIE (compact URI
expressions) [15] and QNames (qualified names) [21]. Both are comprised of two
components: an optional prefix and a reference. The prefix is separated from
the reference by a colon. The syntax of QNames is restrictive and does not
allow all possible IRIs to be represented, i.e. issn:15700844 is valid CURIE
but invalid QName. Syntactically, QNames are a subset of CURIEs.

######  Definition 2.3 (Literals).

_Literals_ are a set of lexical forms and datatype IRIs. A lexical form is a
Unicode string, and a datatype IRI identifies an attribute of data that
defines how the user intends to use the data. RDF borrows many of the
datatypes defined in XML Schema 1.1 [140]. For example,
"1"^^http://www.w3.org/2001/XMLSchema#unsignedInt, where 1 is a lexical form
and should be treated as unsigned integer number.∎

Note that in RDF 1.0 literals with a language tag do not support a datatype
URI. In RDF 1.1 literals with language tags have the datatype IRI
rdf:langString. In current version of RDF all literals have datatypes.
Implementations might choose to support syntax for literals that have lexical
form only, but it should be treated as synonyms for xsd:string literals.
Moreover, RDF 1.1 may support the new datatype rdf:HTML. Both rdf:HTML and
rdf:XMLLiteral depend on DOM4 (Document Object Model level 4)111DOM4 is an
interface that treats an XML or HTML elements as objects, see
http://www.w3.org/TR/dom/.

######  Definition 2.4 (Blank nodes).

_Blank nodes_ are defined as elements of an infinite set disjoint from IRIs
and Literals.∎

In RDF 1.1 blank node identifiers are local identifiers adapted in particular
RDF serializations or implementations of an RDF store.

A set of RDF triples represents a labeled directed multigraph. The nodes are
the subjects and objects of their triples. RDF is also related to as being
_graph structured data_ where each $\langle s,p,o\rangle$ triple can be
interpreted as an edge $s\xrightarrow{p}o$.

######  Definition 2.5 (RDF graph).

Let $\mathcal{O}=\mathcal{I}\cup\mathcal{B}\cup\mathcal{L}$ and
$\mathcal{S}=\mathcal{I}\cup\mathcal{B}$.
$G\subset\mathcal{S}\times\mathcal{I}\times\mathcal{O}$ is a finite subset of
_RDF triples_ and called an _RDF graph_.∎

######  Example 2.2.

The example in Fig. 1 presents an RDF graph of a FOAF [23] profile. This graph
includes four RDF triples:

    <#js>   rdf:type    foaf:Person  .
    <#js>   foaf:name   "John Smith" .
    <#js>   foaf:workplaceHomepage <http://univ.com/> .
    <http://univ.com/>  rdfs:label "University"       .

Figure 1: An RDF graph with four triples.

The RDF syntax and semantics can be widened to named graphs [32]. The named
graph data model is a variation of the RDF data model. The basic concept of
the model consists of proposing a graph naming mechanism.

######  Definition 2.6 (Named graph).

A _named graph_ $NG$ is a pair $\langle u,G\rangle$, where
$u\in\mathcal{I}\cup\mathcal{B}$ is a graph name and $G$ is an RDF graph.∎

######  Example 2.3.

The example in Fig. 2 presents a named graph of a FOAF profile. This graph has
the name http://example.com/#people and includes three RDF triples:

    <#people> {
     <#js>  rdf:type   foaf:Person  .
     <#js>  foaf:name  "John Smith" .
     <#js>  foaf:workplaceHomepage <http://univ.com/> .
    }

Figure 2: A named graph identified by <#people> with three triples.

RDF 1.1 describes the idea of RDF datasets, a collection of a distinguished
RDF graph and zero or more graphs with context.Whereas RDF graphs have a
formal semantics that establishes what arrangements of the universe make an
RDF graph true, no agreed model-theoretic semantics exists for RDF datasets.
For more about the above characteristics, we refer the interested reader to
the _RDF 1.1: On Semantics of RDF Datasets_ [164] which specify several
semantics in terms of model theory.

######  Definition 2.7 (RDF dataset).

An _RDF dataset_ $DS$ includes one nameless RDF graph, called the default
graph and zero or more named graphs, where each is identified by IRI or blank
node, $DS=\\{G,\langle u_{1},G_{1}\rangle,\langle
u_{2},G_{2}\rangle,\dots,\langle u_{i},G_{i}\rangle\\}$.∎

######  Example 2.4.

The example presents an RDF dataset consisting of one unnamed (default) graph
and two named graphs.

    { }  # empty RDF graph
    ex:g1 { ex:s  ex:p  ex:o }
    ex:g2 { ex:x  ex:y  ex:z }

In addition, the RDF Schema Recommendation [22] provides a set of built-in
vocabulary terms under a core RDF namespace that unifies popular RDF patterns,
such as RDF collections, containers, and RDF reification.

RDF is a provider of vocabularies for container description. Each container
has a type; what is more, their members can be itemized with the use of a
fixed set of container membership properties. In order to provide a way to
separate the members from one another, the properties must be indexed by
integers, however, these indexes can not be regarded as specifying an ordering
of the RDF container itself. The RDF containers are RDF graph entities that
use the vocabulary in order to provide basic information about the entities
and give a description of the container members. Following [22], RDF gives
vocabularies for specifying three container classes:

  * •

rdf:Bag is unordered container and allows duplicates,

  * •

rdf:Seq is ordered container,

  * •

rdf:Alt is considered to define a group of alternatives.

######  Example 2.5.

The example presents an rdf:Bag container representing the group of resources.

    <http://example.com/p> ex:teachers _:a .
    _:a rdf:type rdf:Bag .
    _:a rdf:_1 <http://example.com/p/js> .
    _:a rdf:_2 <http://example.com/p/ak> .

Another feature of RDF is its vocabulary for describing RDF collections. Since
the RDF data model has no inherent ordering, collections can be used to
determine an ordered and linear collection using a linked list pattern. RDF
collections are in the form of a linked list structure such that it comprises
of elements with a member and a pointer to the next element. Moreover,
collections are closed lists in contrast to containers, which allow the set of
items in the group to be precisely determined by applications. However cyclic
or unterminated lists in RDF are possible.

######  Example 2.6.

The example presents a collection representing the group of resources. In the
graphs, each member of the collection is the object of the rdf:first predicate
whose subject is a blank node representing a list, that links by the rdf:rest
predicate. The rdf:rest predicate, with the rdf:nil resource as its object,
indicates the end of the list.

    <http://example.com/p> ex:teachers _:x .
    _:x rdf:first <http://example.com/p/js> .
    _:x rdf:rest _:y .
    _:y rdf:first <http://example.com/p/ak> .
    _:y rdf:rest rdf:nil .

Another RDF feature is reification (denoted sr in Table 1), which provides an
approach to talk about individual RDF triples themselves within RDF. The
method allows for constructing a new resource that refers to a triple, and
then for adding supplementary information about that RDF statement.

######  Example 2.7.

The example presents a standard RDF reification.

    ex:t rdf:type      rdf:Statement .
    ex:t rdf:subject   <#js> .
    ex:t rdf:predicate foaf:name .
    ex:t rdf:object    "John Smith" .
    ex:t ex2:certainty 0.5 .

An extension of the previous method is N-ary Relations [111] (denoted nr in
Table 1). This approach is not strictly designed for reification, but focuses
on additional arguments in the relation to provide extra information about the
relation instance itself.

######  Example 2.8.

The example presents an N-ary Relations.

    <#js> foaf:name "John Smith" .
    <#js> ex2:certainty _:r .
    _:r ex2:certainty-value 0.5 .

There are other proposals [82, 109] of RDF reification. The first proposal
called RDF*/RDR222Also known as Reification Done Right (RDR) [82] (denoted rdr
in Table 1) is an alternative approach to represent statement-level metadata.
It is based on the idea of using a triple in the subject or object positions
of other triples that represent metadata about the embedded statement. To
reified RDF data an additional file format based on Turtle has been
introduced. Unfortunately, in RDF*/RDR several reification statements of the
same triple are translated into one standard reification part so that, it is
not possible to distinguish grouped annotations.

######  Example 2.9.

The example presents an RDF*/RDR.

    <<<#js> foaf:name "John Smith">> ex2:certainty 0.5 .

The second proposal is called Singleton Property [109] (denoted sp in Table
1). It is for representing statements about statements. It uses a unique
predicate for every triple with associated metadata to the statement, which
can be linked to the high-level predicate. Authors propose special predicate
singletonPropertyOf to link to original predicate. Since the predicate
resource use predicate singletonPropertyOf, it is possible to use RDFS
entailment rules to infer the original statements.

######  Example 2.10.

The example presents a Singleton Property.

    foaf:name#1 rdf:singletonPropertyOf foaf:name .
    <#js> foaf:name#1 "John Smith" .
    foaf:name#1 ex2:certainty 0.5 .

It is also possible to use named graphs directly (denoted ng in Table 1). A
named graph concept allows assigning an IRI for one or more triples as a graph
name. In that scenario, the graph name is used as a subject that can store the
metadata about the associated triples. In [76] authors present a model of
nanopublications along with a named graph notation.

######  Example 2.11.

The example presents a named graph with metadata.

    <g1> { <#js> foaf:name "John Smith" }
    <g1> ex2:certainty 0.5 .

In Table 1 we present features of the above-mentioned standardized
serializations, namely: having W3C Recommendation, special syntax that is an
extension of RDF, and number of extra RDF statements required to represent an
RDF triple (i.e. $O(n)$).

Table 1: RDF reifications. This table presents the features of reifications, namely: having W3C Recommendation (yes – ☑, no – ⌧), RDF-compatible syntax (yes – ☑, partial – □, no – ⌧) and number of extra statements. Feature | sr | nr | rdr | sp | ng
---|---|---|---|---|---
Standard | ☑ | ☑⋆ | ⌧ | ⌧ | ☑
RDF syntax only | ☑ | ☑ | ⌧ | ⌧ | □
Extra statements | $4n$ | $2n$ |  $n$⋆⋆ | $2n$ |  $n$⋆⋆⋆
⋆ W3C Working Group Note
⋆⋆ Counted as n-tripleX
⋆⋆⋆ Counted as n-quads

##  3 Modeling Blank Nodes

The standard semantics for blank nodes interprets them as existential
variables. We provide an alternative formulation for the blank nodes, and look
at theoretic aspects of blank nodes.

Following [38], blank nodes give the capability to:

  * •

define the information to encapsulate the N-ary association,

  * •

describe reification,

  * •

offer protection of the inner data,

  * •

describe multi-component structures (e.g. RDF containers),

  * •

represent complex attributes without having to name explicitly the auxiliary
node.

The complexity of the problem of deciding whether or not two RDF graphs with
blank nodes are isomorphic is GI-complete as noticed in [31]. Graph
isomorphism complexity with a total absence of blank nodes is PTIME [103].

There is a complication in the notion of RDF graphs, caused by blank nodes.
Blank nodes are intended to be locally-scoped terms that are interpreted as
existential variables. Blank nodes are shared by graphs only if they are
derived from the ones described by documents or RDF datasets that provide for
the blank nodes sharing between different graphs. Performing a document
download is not synonymous with the blank nodes in a resulting graph being
identical to the blank nodes coming from the same source or other downloads of
the same file. This gives rise to a notion of _isomorphism_ between RDF graphs
that are the same up to blank node relabeling: isomorphic RDF graphs can be
considered as containing the same content.

######  Definition 3.1 (Graph isomorphism).

Two RDF graphs $G_{1}$ and $G_{2}$ are identical in form (are _isomorphic_ ,
denoted $G_{1}\cong G_{2}$) if there is a bijective function $M$ between the
nodes sets of the two graphs, such that:

  1. 1.

$M:\mathcal{B}\rightarrow\mathcal{B}$,

  2. 2.

$M_{|\mathcal{L}}=\mathrm{id_{\mathcal{L}}}$, for all literals that are nodes
of graph $G_{1}$,

  3. 3.

$M_{|\mathcal{I}}=\mathrm{id_{\mathcal{I}}}$, for all RDF IRIs that are nodes
of graph $G_{1}$,

  4. 4.

$\forall_{s,p,o}(\langle s,p,o\rangle\in G_{1}\Leftrightarrow\langle
M(s),p,M(o)\rangle\in G_{2})$.

∎

Moreover, merging two or more RDF graphs is important to ensure that there are
no conflicts in blank node labels. A merging operation performs the union
after forcing all of shared blank nodes that are present in two or more graphs
to be distinct in each RDF graph. The graph after this operation is called the
_merge_. The result of this operation on RDF graphs can produce more nodes
than the original graphs.

######  Definition 3.2 (RDF merge).

Given two graphs, $G_{1}$ and $G_{2}$, an _RDF merge_ of these two graphs,
denoted $G_{1}\uplus G_{2}$, is defined as the set union $G_{1}^{\prime}\cup
G_{2}^{\prime}$, where $G_{1}^{\prime}$ and $G_{2}^{\prime}$ are isomorphic
copies of $G_{1}$ and $G_{2}$ respectively such that the copies do not share
any blank nodes.∎

As in the RDF graphs we can compare RDF datasets.

######  Definition 3.3 (Dataset isomorphism).

Two RDF datasets $DS_{1}$ and $DS_{2}$ are _dataset-isomorphic_ if there is a
function $M:\mathcal{B}\rightarrow\mathcal{B}$ between the triples, graphs and
nodes in the two datasets, respectively, such that:

  1. 1.

$M$ is the identity map on RDF literals and IRIs, i.e.
$M_{|\mathcal{I}\cup\mathcal{L}}=\mathrm{id_{\mathcal{I}\cup\mathcal{L}}}$,

  2. 2.

for every $G\in DS_{1}$ such that $G=\\{t_{1},t_{2},\dots,t_{n}\\}$,
$M(G)=\\{M(t_{1}),M(t_{2}),\dots,M(t_{n})\\}\in DS_{2}$,

  3. 3.

for every $G\in DS_{1}$, $\forall_{s,p,o}\langle s,p,o\rangle\in
G\Leftrightarrow\langle M(s),M(p),M(o)\rangle\in M(G)$,

  4. 4.

$\forall_{u,G}(\langle u,G\rangle\in NG_{1}\Leftrightarrow\langle
M(u),M(G)\rangle\in NG_{2})$.

∎

Blank nodes identifiers cannot be found in the RDF abstract syntax. Giving a
constant name to the blank nodes can be helped by the skolemization mechanism
[86]. In situations where stronger identification is needed, some or all of
the blank nodes can be replaced with IRIs. Systems that wish to do so ought to
create a globally unique IRI (called a _skolem IRI_) for every blank node so
replaced. This conversion does not significantly change the graph meaning. It
permits the possibility of other RDF graphs by subsequent use the skolem IRIs
that is impossible for blank nodes. Systems use a _well-known IRI_ [110] when
they need skolem IRIs to be distinguishable outside of the system boundaries
with the registered name genid.

######  Definition 3.4 (Skolemization).

Assume that $G$ is a graph including blank nodes,
$\xi:\mathcal{B}\rightarrow\mathcal{I}_{skolem}$ is a skolemization injective
function and $\mathcal{I}_{skolem}$ is a subset of skolem IRIs which is
substituted for a blank node and not occur in any other RDF graph.∎

From the above definition it follows that
$\mathcal{I}_{skolem}\cap\mathcal{I}_{G}=\emptyset$, where $\mathcal{I}_{G}$
is a set of IRIs that are used in $G$.

On the other hand, in [103], authors propose two skolemization schemes, such
as: centralized and decentralized. The first one is very similar to what the
URL shortening service does. Formally, there is a distinguished subset of the
URIs. Whenever the service receives a request, it returns an element that is
in Skolem constants such that it has not been used before. The second proposal
resembles the first but with no central service. As a result, each publisher
will generate its constants locally. Another proposal [87] focuses on a scheme
to produce canonical labels for blank nodes, which maps them to globally
canonical IRIs. It guarantees that two skolemized graphs will be equal if and
only if the two RDF graphs are isomorphic.

NP-completeness originate from cyclic blank nodes. In [88], authors discuss a
number of possible alternatives for blank nodes, such as:

  1. 1.

disallow blank node,

  2. 2.

ground semantics,

  3. 3.

well-behaved RDF.

The first alternative disallows the use of blank nodes in RDF. However, blank
nodes are a useful convenience for publishers. The second alternative proposes
to assign blank nodes a ground semantics, such that they are interpreted in a
similar fashion to IRIs. The third alternative is also presented in [20]. The
core motivation for this proposal is to allow implementers to develop
tractable lightweight methods that support the semantics of blank nodes for an
acyclical case. Following [20], a _well-behaved RDF graph_ is a graph that
conforms to the restrictions, which we present below.

######  Definition 3.5 (Well-behaved RDF graph).

A _well-behaved RDF graph_ is an RDF graph that conforms to the following
restrictions:

  1. 1.

it can be serialized as Turtle without the use of explicit blank node
identifiers,

  2. 2.

it uses no deprecated features of RDF.

∎

Note that the first version of RDF published in 1999 did not have named blank
nodes and thus was per definition well-behaved.

Another important concept is leanness, which is checking if an RDF graph
contains redundancy.

######  Definition 3.6 (Subgraph and lean graph).

A _subgraph_ is a subset of a graph $G$. Assume that a function
$\nu:\mathcal{I}\cup\mathcal{B}\cup\mathcal{L}\rightarrow\mathcal{I}\cup\mathcal{B}\cup\mathcal{L}$
preserving IRIs and literals. An RDF graph $G$ is _lean_ if there is no
function $\nu$ such that $\nu(G)$ is a subgraph of $G$.∎

Please note that a subgraph can be a graph with fewer triples. The complexity
of the problem of verifying whether or not an RDF graph is lean is coNP-
complete as noticed in [79]. Alongside the notion of graphs being non-lean, we
also intuitively refer to blank nodes as being non-lean. Non-lean blank nodes
are the cause of redundant triples in non-lean graphs. A graph is non-lean if
and only if it contains one or more non-lean blank nodes.

######  Example 3.1.

The example presents that the top graph is lean, because there is no proper
map into itself. The bottom graph in not lean.

##  4 Entailments

An interpretation in RDF is a function from literals and IRIs into a set,
together with restrictions upon the mapping and the set. In this section we
introduce different interpretation notions from the RDF area, each
corresponding to an entailment regime in a standard way.

Following [115], a _simple interpretation_ $I$ is a structure which we present
below.

######  Definition 4.1 (Simple interpretation).

A _simple interpretation_ is $I=\langle R^{I},P^{I},EXT^{I},INT^{I}\rangle$,
where:

  1. 1.

$R^{I}$ is a (nonempty) set of named resources (the universe of $I$),

  2. 2.

$P^{I}$ is a set, called the set of properties of $I$,

  3. 3.

$EXT^{I}$ is an extension function used to associate properties with their
property extension, $EXT^{I}:P^{I}\rightarrow 2^{R^{I}\times R^{I}}$,

  4. 4.

$INT^{I}$ is the interpretation function which assigns a resource or a
property to every element of $V$ such that $INT^{I}$ is the identity for
literals, $INT^{I}:V\rightarrow R^{I}\cup P^{I}$.

∎

The interpretation is a map from expressions i.e. triples, graphs and names to
truth values and universe elements. Following terminology, we say that $I$
_satisfies_ an RDF graph $H$ when $I(H)=true$, that $H$ is _satisfiable_ if it
is a simple interpretation that satisfies it. Moreover, an RDF graph $G$
_entails_ a graph $H$ when every interpretation that satisfies $G$, will
satisfy $H$ as well. In this case, we shall write $G\models H$. The graphs $G$
and $H$ are logically _equivalent_ if each entails the other. Simple
entailment can be directly stated in terms of graph homomorphism as noticed in
[115].

Ter Horst also proved the NP-completeness of simple entailment by reduction
from the clique problem [146]. If the RDF graph $H$ lacks of blank nodes, this
issue is in PTIME, because one should only check that each triple in $H$ is in
$G$ too.

Following [115], blank nodes are seen as simply indicating a thing’s
existence, without handling an IRI to identify any name of a resource. We need
to define a version of the simple interpretation mapping that includes the set
of blank nodes as part of its domain.

######  Definition 4.2 (Semantic condition for blank nodes).

Let $G$ be a graph and $I$ be a simple interpretation. Let
$\alpha:\mathcal{B}\rightarrow R^{I}$ be a map from blank nodes to resources
and let $INT_{\alpha}$ denote an amended version of $INT^{I}$ that includes
$\mathcal{B}$ as part of its domain such that $INT^{I}(x)=\alpha(x)$ for
$x\in\mathcal{B}$ and $INT_{\alpha}(x)=INT^{I}(x)$ for
$x\in\mathcal{I}\cup\mathcal{L}$. We say that $I$ is a model of graph $G$ if
there exists a function $\alpha$ such that for each $\langle s,p,o\rangle\in
G$, it holds that $INT^{I}(p)\in P^{I}$ and
$(INT_{\alpha}(s),INT_{\alpha}(o))\in EXT^{I}(INT^{I}(p))$.∎

When two RDF graphs share a blank node, their meaning is not fully captured by
treating them in isolation. RDF graphs can be viewed as conjunctions of simple
atomic sentences in First-Order Logic (FOL) [49], where blank nodes are free
variables which are existential.

Further interpretations are depending on which IRIs are known as datatypes.
Hayes and Patel-Schneider [115] propose the use of a parameter $D$ (the set of
known datatypes) on simple interpretations. The next considered interpretation
is _$D$ -interpretation_.

######  Definition 4.3 ($D$-interpretation).

Let $D$ be a set of IRIs describing datatypes. A _$D$ -interpretation_ is a
simple interpretation additionally satisfying the following conditions:

  1. 1.

If rdf:langString $\in D$, then for every language-tagged string $E$ with
lexical form $s_{l}$ and language tag $t_{l}$, $L^{I}(E)=\langle
s_{l},t_{l}^{\prime}\rangle$, where $t_{l}^{\prime}$ is $t_{l}$ transformed to
lower case,

  2. 2.

For every other IRI $d\in D$, $I(d)$ is the datatype identified by $d$, and
for every literal ”$s_{l}$”^^$d$, $L^{I}($”$s_{l}$”^^$d)=L2V(I(d))(s_{l})$,
where $L2V$ is a function from datatypes to their lexical-to-value mapping.

∎

Note that in the RDF 1.0 specification, datatype $D$-entailment was described
as an RDFS-entailment semantic extension. In RDF 1.1 it is defined as a simple
direct extension. Moreover, in RDF 1.1 datatype entailment formally refers to
a set of recognized datatypes IRIs. RDF 1.0 used the concept of a datatype
map: in the new semantic description, this is the mapping from recognized IRIs
to the datatypes they identify.

A graph is _satisfiable_ recognizing $D$ (or simply $D$-satisfiable) if it has
the true in some $D$-interpretation, and $G$ _entails_ recognizing $D$ (or
$D$-entails) $H$ when every $D$-interpretation satisfies $G$, will satisfy
satisfies $H$ as well.

In [146] ter Horst proposes the $D*$ semantics, which is a weaker variant of
RDFS 1.0 $D$ semantics. This semantics generalizes the RDFS 1.0 semantics [83]
to add reasoning with datatypes.

RDF interpretation imposes additional semantic conditions on part of the
(infinite) set of IRIs with the namespace prefix rdf: and xsd:string datatype.
In RDF there are three key terms:

  * •

rdf:Property ($\mathbf{P}$) – the class of RDF properties,

  * •

rdf:type ($\mathbf{a}$) – the subject is an instance of a class,

  * •

rdf:langString ($\mathbf{ls}$) – the class of language-tagged string literal
values.

######  Definition 4.4 (RDF interpretation).

An _RDF interpretation_ is a $D$-interpretation $I$ where $D$ has xsd:string
and rdf:langString, which satisfies the following conditions:

  1. 1.

$x\in P^{I}\Leftrightarrow\langle x,I(\mathbf{P})\rangle\in
EXT^{I}(\mathbf{a})$,

  2. 2.

$\forall_{d\in I}(\langle x,I(d)\rangle\in
EXT^{I}(I(\mathbf{a}))\Leftrightarrow x\in VS(I(d)))$, where $VS$ is a value
space.

∎

This RDF vocabulary is defined by the RDF Semantics [115] in terms of the RDF
model theory. A selection of the inference rules are presented in Table 2. As
earlier $G$ RDF _entails_ $H$ recognizing $D$ when RDF interpretation
recognizing $D$ that satisfies $G$, will satisfy $H$ as well. When $D$ is
{xsd:string, rdf:langString} then $G$ RDF entails $H$.

Table 2: A selection of RDF rules. A rule of the form body $\Rightarrow$ head has predicates to the left of the $\Rightarrow$ symbol are the premise of the rule, and predicates to the right of the $\Rightarrow$ symbol are the consequent. Rule ID | Body | Head
---|---|---
rdf1 |  $?s$ $?p$ ”$s_{l}$”^^$d$ . $d\in D$ |  $\Rightarrow$ $?s$ $?p$ _:n . _:n $\mathbf{a}$ $d$ .
rdf2 |  $?s$ $?p$ $?o$ . |  $\Rightarrow$ $?p$ $\mathbf{a}$ $\mathbf{P}$ .

RDF Schema [22] extends RDF to additional vocabulary with more complex
semantics. RDFS semantics introduces a _class_. It is a resource which
constitutes a set of things that all have class as a value of their rdf:type
predicate (so-called property). They are outlined to be things of type
rdfs:Class. We introduce $C^{I}$ which is the set of all classes in an
interpretation. Additionally, the semantic conditions are stated in terms of a
function $CEXT^{I}:C^{I}\rightarrow 2^{R^{I}}$. In RDFS there are ten key
terms:

  * •

rdfs:Class ($\mathbf{C}$) – the class of classes,

  * •

rdfs:Literal ($\mathbf{Lit}$) – the class of literal values,

  * •

rdfs:Resource ($\mathbf{Res}$) – the class resource, everything,

  * •

rdfs:Datatype ($\mathbf{Dt}$) – the class of RDF datatypes,

  * •

rdfs:subPropertyOf ($\mathbf{spo}$) – the property that allows for stating
that all things related by a given property $x$ are also necessarily related
by another property $y$,

  * •

rdfs:subClassOf ($\mathbf{sco}$) – the property that allows for stating that
the extension of one class $X$ is necessarily contained within the extension
of another class $Y$,

  * •

rdfs:domain ($\mathbf{dom}$) – the property that allows for stating that the
subject of a relation with a given property $x$ is a member of a given class
$X$,

  * •

rdfs:range ($\mathbf{rng}$) – the property that allows for stating that the
object of a relation with a given property $x$ is a member of a given class
$X$,

  * •

rdfs:ContainerMembershipProperty ($\mathbf{Cmp}$) – the class of container
membership properties, rdf:_$i$,

  * •

rdfs:member ($\mathbf{m}$) – a member of the subject resource.

######  Definition 4.5 (RDFS interpretation).

An _RDFS interpretation_ is an RDF interpretation which additionally satisfies
the following conditions:

  1. 1.

$CEXT^{I}(y)=\\{x:\langle x,y\rangle\in EXT^{I}(INT^{I}(\mathbf{a})\\}$,

  2. 2.

$IC=CEXT^{I}(INT^{I}(\mathbf{C}))$,

  3. 3.

$LV=CEXT^{I}(INT^{I}(\mathbf{Lit}))$,

  4. 4.

$CEXT^{I}(INT^{I}(\mathbf{Res}))=R^{I}$,

  5. 5.

$CEXT^{I}(INT^{I}(\mathbf{ls}))=\\{INT^{I}(E):E$ is a language-tagged string
$\\}$,

  6. 6.

$\forall_{d\in\mathcal{I}\backslash(\mathbf{Res}\cup\mathbf{ls})}CEXT^{I}(INT^{I}(d))=VS(INT^{I}(d))$,
where $VS$ is a value space,

  7. 7.

$\forall_{d\in\mathcal{I}}INT^{I}(d)\in CEXT^{I}(INT^{I}(\mathbf{Dt}))$

  8. 8.

$\langle x,y\rangle\in EXT^{I}(INT^{I}(\mathbf{dom}))\wedge\langle
u,v\rangle\in EXT^{I}(x)\Rightarrow u\in CEXT^{I}(y)$,

  9. 9.

$\langle x,y\rangle\in EXT^{I}(INT^{I}(\mathbf{rng}))\wedge\langle
u,v\rangle\in EXT^{I}(x)\Rightarrow v\in CEXT^{I}(y)$,

  10. 10.

$\forall_{x,y,z\in P^{I}}(\langle x,y\rangle\in
EXT^{I}(INT^{I}(\mathbf{spo}))\wedge\langle y,z\rangle\in
EXT^{I}(INT^{I}(\mathbf{spo})))\Rightarrow\langle x,z\rangle\in
EXT^{I}(INT^{I}(\mathbf{spo})))\wedge\forall_{x\in P^{I}}\langle x,x\rangle\in
EXT^{I}(INT^{I}(\mathbf{spo}))$

  11. 11.

$\langle x,y\rangle\in EXT^{I}(INT^{I}(\mathbf{spo}))\Rightarrow x\in
P^{I}\wedge y\in P^{I}\wedge CEXT^{I}(x)\subset CEXT^{I}(y)$,

  12. 12.

$x\in C^{I}\Rightarrow\langle x,INT^{I}(\mathbf{Res})\rangle\in
EXT^{I}(INT^{I}(\mathbf{sco}))$

  13. 13.

$\forall_{x,y,z\in P^{I}}(\langle x,y\rangle\in
EXT^{I}(INT^{I}(\mathbf{sco}))\wedge\langle y,z\rangle\in
EXT^{I}(INT^{I}(\mathbf{sco})))\Rightarrow\langle x,z\rangle\in
EXT^{I}(INT^{I}(\mathbf{sco})))\wedge\forall_{x\in P^{I}}\langle
x,x\rangle\quad\in\quad EXT^{I}(INT^{I}(\mathbf{sco}))$

  14. 14.

$\langle x,y\rangle\in EXT^{I}(INT^{I}(\mathbf{sco}))\Rightarrow x\in
C^{I}\wedge y\in C^{I}\wedge CEXT^{I}(x)\subset CEXT^{I}(y)$,

  15. 15.

$x\in CEXT^{I}(INT^{I}(\mathbf{Cmp}))\Rightarrow\langle
x,INT^{I}(\mathbf{m})\rangle\in EXT^{I}(INT^{I}(\mathbf{spo}))$,

  16. 16.

$x\in CEXT^{I}(INT^{I}(\mathbf{Dt}))\Rightarrow\langle
x,INT^{I}(\mathbf{Lit})\rangle\in EXT^{I}(INT^{I}(\mathbf{sco}))$.

∎

This RDFS vocabulary is defined by the RDF Semantics [115] in terms of the RDF
model theory. Selections of the RDFS inference rules are presented in Table 3.

As earlier $G$ RDFS entails $H$ recognizing $D$ when every RDFS interpretation
recognizing $D$ which satisfies $G$, will satisfy $H$ as well.

Table 3: A selection of RDFS rules. A rule of the form body $\Rightarrow$ head has predicates to the left of the $\Rightarrow$ symbol are the premise of the rule, and predicates to the right of the $\Rightarrow$ symbol are the consequent. Rule ID | Body | Head
---|---|---
rdfs1 | any IRI $?p\in D$ |  $\Rightarrow$ $?p$ $\mathbf{a}$ $\mathbf{Dt}$ .
rdfs2 |  $?p$ $\mathbf{dom}$ $?x$ . $?y$ $?p$ $?z$ . |  $\Rightarrow$ $?y$ $\mathbf{a}$ $?x$ .
rdfs3 |  $?p$ $\mathbf{rng}$ $?x$ . $?y$ $?p$ $?z$ . |  $\Rightarrow$ $?z$ $\mathbf{a}$ $?x$ .
rdfs4a |  $?x$ $?p$ $?y$ . |  $\Rightarrow$ $?x$ $\mathbf{a}$ $\mathbf{Res}$ .
rdfs4b |  $?x$ $?p$ $?y$ . |  $\Rightarrow$ $?y$ $\mathbf{a}$ $\mathbf{Res}$ .
rdfs5 |  $?x$ $\mathbf{spo}$ $?y$ . $?y$ $\mathbf{spo}$ $?z$ . |  $\Rightarrow$ $?x$ $\mathbf{spo}$ $?z$ .
rdfs6 |  $?x$ $\mathbf{a}$ $\mathbf{P}$ . |  $\Rightarrow$ $?x$ $\mathbf{spo}$ $?x$ .
rdfs7 |  $?p$ $\mathbf{spo}$ $?q$ . $?x$ $?p$ $?y$ . |  $\Rightarrow$ $?x$ $?q$ $?y$ .
rdfs8 |  $?x$ $\mathbf{a}$ $\mathbf{C}$ |  $\Rightarrow$ $?x$ $\mathbf{sco}$ $\mathbf{Res}$ .
rdfs9 |  $?x$ $\mathbf{sco}$ $?y$ . $?z$ $\mathbf{a}$ $?x$ . |  $\Rightarrow$ $?z$ $\mathbf{a}$ $?y$ .
rdfs10 |  $?x$ $\mathbf{a}$ $\mathbf{C}$ . |  $\Rightarrow$ $?x$ $\mathbf{sco}$ $?x$ .
rdfs11 |  $?x$ $\mathbf{sco}$ $?y$ . $?y$ $\mathbf{sco}$ $?z$ . |  $\Rightarrow$ $?x$ $\mathbf{sco}$ $?z$ .
rdfs12 |  $?x$ $\mathbf{a}$ $\mathbf{Cmp}$ . |  $\Rightarrow$ $?x$ $\mathbf{spo}$ $\mathbf{m}$ .
rdfs13 |  $?x$ $\mathbf{a}$ $\mathbf{Dt}$ . |  $\Rightarrow$ $?x$ $\mathbf{sco}$ $\mathbf{Lit}$ .

######  Example 4.1.

The example presents an RDFS interpretation for the vocabulary presented in
Example 2.2.

$R^{I}\quad=$ | $\\{\Upsilon,\Phi,\Psi,\Omega,\alpha,\beta,\gamma,\delta,\epsilon\\}$ |
---|---|---
$P^{I}\quad=$ | $\\{\Upsilon,\Phi,\Psi,\Omega\\}$ |
$EXT^{I}\quad=$ | $\Upsilon$ | $\mapsto\quad\\{\langle\alpha,\beta\rangle\\}$
| $\Phi$ | $\mapsto\quad\\{\langle\alpha,\delta\rangle\\}$
| $\Psi$ | $\mapsto\quad\\{\langle\alpha,\gamma\rangle\\}$
| $\Omega$ | $\mapsto\quad\\{\langle\gamma,\epsilon\rangle\\}$
$INT^{I}\quad=$ | rdf:type | $\mapsto\quad\Upsilon$
| foaf:name | $\mapsto\quad\Phi$
| foaf:workplaceHomepage | $\mapsto\quad\Psi$
| rdfs:label | $\mapsto\quad\Omega$
| <#js> | $\mapsto\quad\alpha$
| foaf:Person | $\mapsto\quad\beta$
| ”John Smith” | $\mapsto\quad\gamma$
| <http://univ.com/> | $\mapsto\quad\delta$
| ”University” | $\mapsto\quad\epsilon$

In Table 4 we summarize results about complexity of entailment problems
mentioned above.

Table 4: Computational complexity of entailments for RDF and RDFS Entailment | Current semantics | No blank nodes
---|---|---
simple |  NP-complete | PTIME
D* |  NP-complete | PTIME
RDF |  NP-complete | PTIME
RDFS |  NP-complete | PTIME

######  Example 4.2.

The example presents that the top graph entails the bottom graph. When we
blank the node <#js> from the top, the bottom graph still has a node that
represents a person and preserves semantics. Similarly, when we delete the
node "John Smith" from the top graph, the bottom graph still preserves the
graph’s semantics.

##  5 RDF Data Integration

The role of RDF as an integration system for data from different sources is
one of the crucial motivations for research efforts. It is important to
provide integration methods to bridge the gap between the RDF and other
environments. Following [100], the definition of data integration systems is
provided below.

######  Definition 5.1 (Data integration system).

A _data integration system_ is a tuple
$\langle\mathcal{G},S,\mathcal{M}\rangle$ where $\mathcal{G}$ is the global
schema, $S$ is the source schema and $\mathcal{M}$ is the mapping between
$\mathcal{G}$ and $S$, constituted by a set of assertions.∎

In this section the approaches of mapping of relational databases to RDF are
discussed (Subsection 5.1) as well as approaches of mapping XML to RDF
(Subsection 5.2). However, there are also more general approaches [41, 42, 1,
122, 117, 145, 56].

###  5.1 Bringing Relational Databases into the RDF

This subsection contains an overview and comparison of the approaches for
mapping from a relational database into RDF. Table 5 presents the key
approaches from related work. It presents the features of the below-mentioned
proposals, namely: mapping representation (SQL, RDF, XML, etc.), schema
representation (RDF, OWL [89] and F-Logic [93]) and level of automation.

Table 5: Relational databases mapping. This table presents the features of
transformation approaches, namely: mapping representation, schema
representation and level of automation (automatic – ☑, semi-automatic – □ and
manual – ⌧)

.  Approaches Mapping Schema Automatic Represent. Represent. [5, 6] n/a RDFS,
OWL, F-Logic □ [8] SQL RDFS ⌧ [34, 35] Constraint rules RDFS, OWL □ [18] D2RQ
RDFS ☑ [46] RDF, Rel.OWL RDFS, OWL ☑ [24] n/a RDFS, OWL □ [90] FOL, Horn RDFS,
OWL ☑ [25] SQL RDFS, OWL ⌧ [101] Logic rules RDFS, OWL □ [27] n/a RDFS □ [28]
XML RDFS, OWL ⌧ [58] SPARQL RDFS ☑⋆ [72] R2O RDFS, OWL ☑ [84] RDF RDFS ⌧ [112]
RDF, Rel.OWL RDFS, OWL ☑ [119] D2RQ RDFS, OWL □ [127] XPath (XSLT) RDFS, OWL ⌧
[128] SQL RDFS, OWL □ [136] n/a RDFS, OWL ☑ [143] n/a RDFS, F-Logic □ [150]
FOL RDFS, OWL ☑ [158] SQL RDFS, OWL ⌧ [160] RDF/XML RDFS, OWL ⌧ [132] RDF
(Direct) RDFS ☑⋆ [102, 17] XQuery n/a □ ⋆ possible manual level

At the beginning, we focus on solutions [8, 128, 158] based on SQL as mapping
representation. Triplify [8] is based on the mapping of HTTP requests onto
database queries expressed in SQL queries, which are used to match subsets of
the store contents and map them to classes and properties. It converts the
resulting relations into RDF triples and subsequently publishes it in various
RDF syntaxes. That proposal includes an approach for publishing update logs in
RDF which contain all RDF resources in order to enable incremental crawling of
data sources. An additional advantage is that it can be easily integrated and
deployed with the numerous, widely installed Web applications. The next
approach is StdTrip [128], which proposes a structure-based framework using
existing ontology alignment software. The approach finds ontology mappings
between simple vocabulary that is generated from a database. The results of
the ontology alignment algorithm are presented as suggestions to the user, who
matches the most appropriate ontology mapping. RDOTE [158] also uses SQL for
the specification of the data subset. In that proposal, the suitable SQL query
is stored in a file. That approach transforms data residing in the database
into RDF graph dump using classes and properties.

The next group of approaches [18, 119] uses D2RQ as mapping representation.
D2RQ [18] supports both automatic and manual operation modes. In the first
mode, RDFS vocabulary is created, in accordance with the reverse engineering
methodologies, for the translation of foreign keys to properties. In the
second mode, the contents of the database are exported to an RDF in accordance
with mappings stored in RDF. It allows RDF applications to treat non-RDF
stores as a virtual RDF graph. It allows RDF applications to treat non-RDF
stores as virtual RDF graphs. One of the disadvantages of D2RQ is a read-only
RDF view of the database. Another D2RQ-based proposal is AuReLi [119], which
uses several string similarity measures associating attribute names to
existing vocabulary entities in order to complete the automation of the
transformation of databases. It also tries to link database values with
ontology individuals. RDF Views [58] has similar functionality to D2RQ. It
supports both automatic and manual operation modes. That solution uses the
table as RDFS class and column as a predicate and takes into account cases
such as whether a column is part of the unique key. The data is represented as
virtual RDF graphs without the physical formation of RDF datasets.

Another group of proposals [84, 132] use RDF. The first approach is OntoAccess
[84], which is a vocabulary-based write access to data. That paper consists of
the relational database to RDF mapping language called R3M, which consists of
an RDF format and algorithms for translating queries to SQL. The next proposal
is SquirrelRDF [132], which extracts data from a number of databases and
integrates that data into a business process. That proposal supports RDF views
and allows for the execution of queries against it. In that group we can also
distinguish solutions [46, 112] based on Relational.OWL [52]. ROSEX [46] uses
Relational.OWL to represent the relational schema of a database as an OWL
ontology. The created database schema annotation and documentation is mapped
to a domain-specific vocabulary, which is achieved automatically by reverse-
engineering the schema. An additional advantage is that it supports automatic
query translation. DataMaster [112] also uses Relational.OWL for the importing
of schema structure and data from relational databases.

R2RML [48] is the best-known language based of RDF for expressing mappings
from relational databases to RDF datasets because it is a W3C recommendation
and has a lot of implementations [120, 133, 59]. R2RML is a language for
specifying mappings from relational to RDF data. A mapping takes as input a
logical table (logicalTable predicate), i.e. a database table, an SQL query,
or a database view. In the next step, a logical table is mapped to triples map
that is a set of triples. Triples map has two main parts. The first part is a
subject map (subjectMap predicate) that generates the subject of all RDF
triples that will be generated from a logical table row. The second part is a
predicate-object map (predicateObjectMap predicate) specifies the target
property and the generation of the object via objectMap.

Yet another type of approaches are [160, 28]. DartGrid [160] describes a
database integration architecture. It uses a visual mapping system to align
the relational database to existing vocabulary. Correspondences between
components of the models which are defined via a graphical user interface are
created and stored in an RDF/XML syntax (see Subsection 6.1). The next
proposal is MASTRO [28], which is a framework that enables the definition of
mappings between a relational database and vocabulary.

Another group of proposals [150, 90] use First-Order Logic (FOL) [49]. Tirmizi
et al. [150] present formal rules in FOL to transform column to predicate and
table to class. The authors present the system which is complete with respect
to a space of the possible primary key and foreign key mixtures. The next
proposal is MARSON [90], which uses mappings based on virtual documents
(called vectors of coefficients). It removes incorrect mappings via validating
mapping consistency. Moreover, a special type of semantic mappings (called
contextual mappings) is presented in the paper.

Some approaches [34, 72, 101, 127, 150, 102] adopt other mapping
representations. RDBToOnto [34, 35] is a tool that simplifies the
implementation of methods for vocabulary acquisition from databases. It
provides a visual interface for manual modification and adjustment of the
learning parameters. RDBToOnto links the data analysis with heuristic rules
and generates an ontology. DB2OWL [72] creates local vocabulary from a
relational database that is aligned to reference vocabulary. The vocabulary
generated in that proposal reflects the database semantics. The mappings are
stored in an R2O [9] document. The next proposal is SOAM [101], which uses the
column to predicate and table to class approach. It creates an initial schema,
which is refined by referring to a dictionary. Constraints are mapped to
constraints in the vocabulary schema. That approach tries to establish the
quality of the constructed vocabulary. Another proposal is [127]. It is a
domain semantics-driven mapping generation approach. Mapping is created on the
XSLT [92] and XPath [137]. Yet another approach is XSPARQL [102], which can be
used both in relational databases and XML (see Subsection 5.2).

There are also several approaches [5, 24, 136, 143, 27] that do not have a
defined mapping representation. Astrova [5, 6] discusses correlation among
key, data in key attributes between two relations and non-key attributes. In
these papers, the quality of transformation is considered. Buccella et al.
[24], Shen et al. [136] and Stojanovic et al. [143] examine heuristic rules.
Byrne [27] proposes a domain-specific approach for the generic design of
cultural heritage data and discusses the options for including published
heritage thesauri.

###  5.2 Bringing XML into the RDF

This subsection overviews and compares the approaches for mapping from XML
into RDF. Table 6, presents key approaches from related work. It presents
features of the below-mentioned proposals, namely: existing vocabulary, schema
representation (RDF, OWL and DAML+OIL [89]) and level of automation.

Table 6: XML mapping. This table presents the features of transformation approaches, namely: existing vocabulary (yes – ☑, no – ⌧), schema representation and level of automation (automatic – ☑, semi-automatic – □ and manual – ⌧) Approaches | Existing | Schema | Auto-
---|---|---|---
| vocabulary | Representation | matic
[3] | ⌧ | RDFS, DAML+OIL | ⌧
[10] | ⌧ | RDFS, OWL | ☑
[11] | ⌧ | RDFS, OWL | ☑
[13] | ⌧ | n/a | ☑
[14] | ⌧ | RDFS, OWL | ☑
[17, 16] | ⌧ | n/a | □
[19] | ⌧ | RDFS, OWL | ☑
[40] | ⌧ | RDFS, OWL | □
[43] | ☑ | RDFS, OWL | ☑
[55] | ☑ | RDFS, OWL | □
[56] | ⌧ | RDFS, OWL | □
[57] | ⌧ | n/a | □
[60] | ⌧ | n/a | □
[62] | ⌧ | RDFS, OWL | ☑
[71] | ⌧ | RDFS, OWL | ☑
[73] | ☑ | RDFS, OWL | ☑
[94] | ⌧ | RDFS | ☑
[95] | ⌧ | RDFS | ☑
[99] | ⌧ | RDFS, OWL | ☑
[113] | ⌧ | RDFS, OWL | □
[124] | ☑ | RDFS, OWL | ☑
[126] | ☑ | RDFS, OWL | ☑
[135] | ⌧ | RDFS, OWL | ☑
[142] | ⌧ | RDFS, OWL | ☑
[149, 148] | ⌧ | RDFS, OWL | □
[154] | ⌧ | n/a | ☑
[161] | ⌧ | RDFS | ☑
[162] | ⌧ | RDFS, OWL | ☑

At the beginning, we focus on solutions [43, 55, 73, 124, 126] that use
existing vocabulary and/or ontology. This means that the XML data is
transformed according to the mapped vocabularies. Cruz et al. [43] propose
basic mapping rules to specify the transformation rules on properties, which
are defined in the XML Schema. Deursen et al. [55] propose the method for the
transformation of XML data into RDF instances in an ontology-dependent way.
X2OWL [73] is a tool that builds an OWL ontology from an XML data source and a
set of mapping bridges. That proposal is based on an XML Schema that can be
modeled using different styles to create the vocabulary structure. The next
proposal is WEESA [124], which is an approach for Web engineering techniques
and developing semantically tagged applications. Another tool is JXML2OWL
[126]. It supports the transformation from syntactic data sources in XML
format to a common shared global model defined by vocabulary.

Another group of proposals [3, 11, 14, 62, 71, 94, 95, 99, 113, 149, 161, 162]
do not support mappings between XML Schemas and existing vocabularies. Amann
et al. [3] discuss a data integration system, where XML is mapped into
vocabulary that supports roles and inheritance. That tool focuses on offering
the appropriate high-level primitives and mechanisms for representing the
semantics of XML data. Janus [11] is a framework that focuses on an advanced
logical representation of XML Schema components and a set of patterns that
enable the transformation from XML Schema into the vocabulary. It supports a
set of patterns that enable the translation from XML Schema into ontology.
SPARQL2XQuery [14] is a framework that transforms SPARQL [80] query into a
XQuery [125] using mapping from vocabulary to XML Schema. It allows query XML
databases. Ferdinand et al. [62] propose two independent mappings: from XML to
RDF graphs and XML Schema to OWL. That proposal allows items in XML documents
to be mapped to different items in OWL. Garcia et al. [71] present a domain-
specific approach that maps the MPEG-7 standard to RDF. Klein [94] proposes a
procedure to transform the XML tree using the RDF primitives by annotating the
XML by RDFS. This procedure can multiply the availability of semantically
annotated RDF data. SWIM [95] is an integration middleware for mediating high-
level queries to XML sources using RDFS. Lehti et al. [99] show how the
ontologies can be used for mapping data sources to a global schema. In this
work, the authors introduce how the inference rules can be used to check the
consistency of such mappings. In this paper, a query language based on XQuery
is presented. O’Connor et al. [113] propose an OWL-based language that can
transform XML documents to arbitrary ontologies. It extends it with Manchester
syntax for XPath to support references to XML fragments. Another framework is
DTD2OWL [149], which changes XML into vocabularies. It also allows
transforming specific XML instances into OWL individuals. Xiao et al. [161]
propose the mappings between XML schemas and local RDFS vocabularies and those
between local vocabulary and the global RDFS vocabulary. The authors discuss
the problem of query containment and present a query rewriting algorithm for
RDQL [51] and XQuery. Yahi et al. [162] propose an approach which covers
schema level and data level. In this proposal XML Schema documents are
generated for XML documents with no schema using the _trang_ tool.

Solutions [13, 19, 57] using XSLT are separate from the ones mentioned above.
Berrueta et al. [13] discuss an XSLT+SPARQL framework, which allows to perform
SPARQL queries from XSLT. It is a collection of functions for XSLT, which
allows to transform the XML results format. Yet another tool is XML2OWL [19],
which uses XSLT for mapping from XML to ontology. Droop et al. [57] propose
another XSLT solution, which allows embedding XPath into SPARQL. Shapkin et
al. [135] propose a transformation language, which is not strictly based on
XLST but inspired by it. That proposal focuses on matching of types of RDF
resources.

Another subgroup of approaches [17, 10, 40, 60, 142, 154] supports mutual
transformation. XSPARQL [17, 16] is a query language based on SPARQL and
XQuery for transformations from RDF into XML and back. It is built on top of
XQuery in a syntactic and semantic view. Gloze [10] is another tool for
bidirectional mapping between XML and RDF. It uses information available in
the XML schema for describing how XML is mapped into RDF and back again. GRDDL
[40] is a markup language that obtains RDF data from XML documents. It is
represented in XSLT. SAWSDL [60] is also a markup language but it proposes a
collection of new attributes for the WSDL [39] and XML Schema. Yet other tools
are SPARQL2XQuery [142] and XS2OWL [154].

##  6 RDF Serializations

Several of RDF syntax formats exist for writing down graphs. RDF 1.1
introduces a number of serialization formats, such as: Turtle, N-Triples,
TriG, N-Quads, JSON-LD, RDFa, and RDF/XML. Note that in RDF 1.1 RDF/XML is no
longer the only recommended serialization format.

In Subsection 6.1, we present serializations that support single graphs. In
Subsection 6.2, we briefly introduce serialization which supports multiple
graphs. Moreover, in this section we show the above-mentioned formats in
examples.

###  6.1 Single Graph Support

RDFa [106] (denoted rdfa in Table 7) is an RDF syntax which embeds RDF triples
in HTML and XML documents. The RDF data is mixed within Document Object Model.
This implies that document content can be marked up with RDFa. It adds a set
of attribute-level extensions to HTML and various XML-based document types for
embedding rich metadata within Web documents. What is more, RDFa allows for
free intermixing of terms from multiple vocabularies. It is also designed in
such a way that the format can be processed without information of the
specific vocabulary being used. It is common in contexts where data publishers
are able to change Web templates but have little additional control over the
publishing infrastructure.

Following [106], we provide the most important attributes that can be used in
RDFa, such as:

  * •

about – an attribute that is an IRI or CURIE [15] specifying the resource the
metadata is about (an RDF subject),

  * •

rel and rev – attributes that expresses (reverse) relationships between two
resources (an RDF predicate),

  * •

property – an attribute that expresses relationships between a subject and
some literal value (an RDF predicate),

  * •

resource – an attribute for expressing a relationship’s partner resource that
is not intended to be navigable (an RDF object),

  * •

href – an attribute that expresses the partner resource of a relationship (an
RDF resource object),

  * •

src – an attribute that expresses a relationship’s partner resource when the
resource is embedded (an RDF object that is a resource),

  * •

content – an attribute that overrides the content of the element when using
the property (an RDF object that is a literal),

  * •

datatype – an attribute that specifies the datatype of a literal,

  * •

typeof – an attribute that specifies the RDF types of the subject or the
partner resource,

  * •

inlist – an attribute that specifies that the object associated with property
or rel attributes on the same element is to be pushed onto the list for that
predicate,

  * •

vocab – an attribute that specifies the mapping to be used when an RDF term is
assigned in a value of attribute.

######  Example 6.1.

The example presents an RDFa 1.1 serialization that represents RDF triples of
Example 2.2.

    <div xmlns="http://www.w3.org/1999/xhtml"
      prefix="
        foaf: http://xmlns.com/foaf/0.1/
        rdf: http://www.w3.org/1999/02/22-rdf-syntax-ns#
        rdfs: http://www.w3.org/2000/01/rdf-schema#"
      >
      <div typeof="foaf:Person" about="http://example.com/p#js">
        <div property="foaf:name">John Smith</div>
        <div rel="foaf:workplaceHomepage">
          <a typeof="rdfs:Resource" href="http://univ.com/">
            <span property="rdfs:label">University</span>
          </a>
        </div>
      </div>
    </div>

RDF/XML [70] (denoted xml in Table 7) is a syntax to serialize an RDF graph as
an XML document. Nevertheless, the syntax is viewed as problematic to read and
write for humans so one should consider using other syntaxes for editors. In
order to process a graph in RDF/XML serialization, there must be a
representation of nodes and predicates in the terms of Extensible Markup
Language (XML) – names of elements, names of attributes, contents of elements
and values of attributes. This syntax uses qualified names (so-called QNames)
to represent IRI references. There are certain restrictions imposed on this
serialization by the XML format and the use of the XML namespace, which
prevents the storage of all RDF graphs as some IRI references are prohibited
by the specifications of these standards.

Following [70], we provide the most important elements and attributes that can
be used in RDF/XML, such as:

  * •

rdf:RDF – a root element of RDF/XML documents,

  * •

rdf:Description – an element that contains elements that describe the
resource, it contains the description of the resource identified by the
rdf:about attribute,

  * •

rdf:Alt, rdf:Bag and rdf:Seq – elements that are containers used to describe a
group of things (see Section 2),

  * •

rdf:parseType="Collection" – an attribute that describe groups that can only
contain the specified members,

  * •

rdf:parseType="Resource" – an attribute that is used to omit blank nodes,

  * •

xml:lang – an attribute that is used to allow content language identification,

  * •

rdf:datatype – an attribute that is used to define a typed literal,

  * •

rdf:nodeID – an attribute that identify a blank node,

  * •

rdf:ID and xml:base – attributes that abbreviate IRIs.

######  Example 6.2.

The example presents an RDF/XML serialization that represents RDF triples of
Example 2.2.

    <?xml version="1.0" encoding="UTF-8"?>
    <rdf:RDF
       xmlns:foaf="http://xmlns.com/foaf/0.1/"
       xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
       xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
    >
      <rdf:Description rdf:about="http://univ.com/">
        <rdfs:label>University</rdfs:label>
      </rdf:Description>
      <rdf:Description rdf:about="http://example.com/p#js">
        <foaf:name>John Smith</foaf:name>
        <rdf:type rdf:resource="http://xmlns.com/foaf/0.1/Person"/>
        <foaf:workplaceHomepage rdf:resource="http://univ.com/"/>
      </rdf:Description>
    </rdf:RDF>

Another RDF syntax refers to Terse RDF Triple Language (Turtle) [121] (denoted
ttl in Table 7). That solution offers textual syntax that enables recording
RDF graphs in a compact form, including abbreviations that use data patterns
and datatypes. Following [121], we provide the most important rules for
constructing the Turtle document:

  * •

The simplest triple statement consists of a sequence of subject, predicate,
and object, separated by space, tabulation or other whitespace and terminated
by a dot after each triple.

  * •

Often, the same subject will be referenced by several predicates. In this
situation, a series of predicates and objects are separated by a semicolon.

  * •

As with predicates, objects are often repeated with the same subject and
predicate. In this case, a comma should be used as a separator.

  * •

IRIs may be written as relative or absolute IRIs or prefixed names. Both
absolute and relative IRIs are enclosed in less-than sign and greater-than
sign.

  * •

Quoted Literals have a lexical form followed by a datatype IRI, a language tag
or neither. Literals should be delimited by apostrophe or double quotes.

  * •

Blank nodes are expressed as underscore, colon and a blank node label that is
a series of name characters. Blank nodes can be nested, abbreviated, and
delimited by square brackets.

  * •

Collections are enclosed by parentheses.

######  Example 6.3.

The example presents a Turtle serialization that represents RDF triples of
Example 2.2.

    @prefix foaf: <http://xmlns.com/foaf/0.1/> .
    prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
    <http://example.com/p#js> a foaf:Person ;
                              foaf:name "John Smith" ;
                              foaf:workplaceHomepage <http://univ.com/> .
    <http://univ.com/> rdfs:label "University" .

N-Triples [30] (denoted nt in Table 7) is a line-based, plain text
serialization format and a subset of the Turtle format minus features such as
shorthands. It means that there is a lot of redundancy, and its files can be
larger than Turtle and RDF/XML. N-Triples was designed to be a simpler format
than Turtle, and therefore easier for software to parse and generate.
Following [30], we provide the most important rules for constructing the
N-Triples document:

  * •

The triple statement consists of a sequence of subject, predicate, and object,
divided by whitespace, and terminated by a dot after each triple.

  * •

IRIs should be represented as absolute IRIs and they are enclosed in less-than
sign and greater-than sign.

  * •

The representation of the lexical form is a sequence of a double quote (an
initial delimiter), a list of characters or escape sequence, and a double
quote (a final delimiter).

  * •

Blank nodes are expressed as underscore, colon and a blank node label that is
a series of name characters.

There are some changes in RDF 1.1 N-Triples, e.g. encoding is UTF-8 rather
than US-ASCII and blank node labels may begin with a digit. Syntactically,
N-Triples is a subset of Turtle.

######  Example 6.4.

The example presents a N-Triples serialization that represents RDF triples of
Example 2.2. Note that we change some RDF term because of legibility.

    <http://example.com/p#js> <http://...#type> <http://...foaf/0.1/Person> .
    <http://example.com/p#js> <http://.../workplaceH...>  <http://univ.com/> .
    <http://example.com/p#js> <http://.../name> "John Smith" .
    <http://univ.com/> <http://...#label> "University" .

###  6.2 Multiple Graphs Support

JSON-LD [141] (denoted jld in Table 7) is a JSON-based format to serialize
structured data such as RDF. The syntax is designed to easily integrate into
deployed systems that use JSON and provides a smooth upgrade path from JSON to
JSON-LD. The use of RDF in JSON makes RDF data accessible to Web developers
without the obligation to install additional parsers, software libraries or
other programs for changing RDF data. Like JSON, JSON-LD uses human-readable
text to transmit data objects consisting of key-value pairs.

Keywords in JSON-LD are starting with at sign. Following [141], we provide the
most important keywords that can be used in JSON-LD, such as:

  * •

@context – set the short-hand names that are used throughout a document,

  * •

@id – uniquely identify things that are being described in the document with
blank nodes or IRIs,

  * •

@value – specify the data that is associated with a particular property,

  * •

@language – define the language for a particular string value or the default
language of a document,

  * •

@type – set the data type of an IRI, a blank node, a JSON-LD value or a list,

  * •

@container – set the default container type for a short-hand string that
expands to an IRI or a blank node identifier,

  * •

@list – define an ordered set of data,

  * •

@set – define an unordered set of data (values are represented as arrays),

  * •

@reverse – used for reverse relationship expression between two resources,

  * •

@index – specify that a container is used to index information,

  * •

@base – define the base IRI against which relative IRIs are resolved,

  * •

@vocab – expand properties and values in @type with a common prefix IRI,

  * •

@graph – express a graph.

######  Example 6.5.

The example presents a JSON-LD serialization that represents RDF triples of
Example 2.3.

    { "@id": "http://example.com/#people",
      "@graph": [
        {
          "@id": "http://univ.com/",
          "http://www.w3.org/2000/01/rdf-schema#label": "University"
        },
        {
          "@id": "http://example.com/p#js",
          "@type": "http://xmlns.com/foaf/0.1/Person",
          "http://xmlns.com/foaf/0.1/name": "John Smith",
          "http://xmlns.com/foaf/0.1/workplaceHomepage": {
            "@id": "http://univ.com/"
           }
        }
      ]
    }

JSON-LD is an RDF syntax. However, it also extends the RDF data model, e.g. in
JSON-LD predicates can be IRIs or blank nodes whereas in RDF have to be IRIs.
JSON-LD can serialize generalized RDF triples, where subjects, predicates, and
objects can be IRIs, blank nodes or literals.

######  Example 6.6.

The example presents a JSON-LD serialization that represents an RDF triple:
<#a> as a subject, blank node as a predicate and "Alice" as an object.

    {
     "@context": {
     "name": "_:b"
     },
     "@id": "#a",
     "name": "Alice"
    }

Another RDF syntax refers to TriG [131] (denoted trig in Table 7). It is a
plain text syntax for RDF datasets serialization. Syntactically, Turtle is
subset of TriG. A document consists of:

  1. 1.

a sequence of directives,

  2. 2.

RDF triples,

  3. 3.

graph statements which contain triple-generating statements.

Graph statements are a pair of blank node label or an IRI with a group of RDF
triples surrounded by curly brackets. The blank node label or IRI of the graph
statement may be used in another graph statement which implies taking the
union of the triples generated by each graph statement. A blank node label or
IRI used as a graph label may also reoccur as part of any RDF triples.

######  Example 6.7.

The example presents a TriG serialization that represents RDF triples of
Example 2.3.

    @prefix foaf: <http://xmlns.com/foaf/0.1/> .
    @prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
    <http://example.com/#people> {
      <http://example.com/p#js> a foaf:Person ;
                                foaf:name "John Smith" ;
                                foaf:workplaceHomepage <http://univ.com/> .
      <http://univ.com/> rdfs:label "University" .
    }

N-Quads [29] (denoted nq in Table 7) is another line-based syntax for
serializing RDF datasets. That plain text format is an RDF syntax similar to
N-Triples. N-Quads line statement is a sequence of RDF terms representing the
RDF triple (subject, predicate and object line in N-Triples) and graph label,
which can be an IRI or blank node. The graph label is also a part of a
dataset, and this sequence is terminated by a dot.

######  Example 6.8.

The example presents a N-Quads serialization that represents RDF triples of
Example 2.3. Note that we change some RDF term because of legibility.

    <http://univ.com/> <http://...#label> "University" <http://...#pe..>.
    <http://example.com/p#js> <http://..#type> <http://../P..> <http://...#pe.>.
    <http://example.com/p#js> <http://.../work...>  <.../> <http://...#pe..>.
    <http://example.com/p#js> <http://.../name> "John ..." <http://...#pe..>.

In Table 7 we present features of the above-mentioned standardized
serializations, namely: having W3C Recommendation, human-friendly syntax
(partial support means that some fragments may be difficult to read), easy to
process, compact form (partial support means that there are several different
forms and not all are normalized), similarity to Turtle syntax and XML-based
syntax and multigraph support. Furthermore, there are a few RDF serializations
that are not standardized, such as TriX [33], RDF/JSON [152, 151].

Table 7: RDF serializations. This table presents the features of serializations, namely: having W3C Recommendation (yes – ☑, no – ⌧), human-friendly syntax (yes – ☑, partial – □, no – ⌧), easy to process (yes – ☑, partial – □, no – ⌧), compact form (yes – ☑, partial – □, no – ⌧), similarity to Turtle syntax and XML-based syntax (yes – ☑, no – ⌧) and multigraph support (yes – ☑, no – ⌧). Feature | ttl | nt | tg | nq | jld | rdfa | xml
---|---|---|---|---|---|---|---
Standard | ☑ | ☑ | ☑ | ☑ | ☑ | ☑ | ☑
Human readable | ☑ | □ | ☑ | □ | ☑ | ☑ | □
Efficient | ⌧ | ⌧ | ⌧ | ⌧ | □ | ⌧ | □
Normalized | ⌧ | ☑ | ⌧ | ☑ | □ | ⌧ | ⌧
Turtle family | ☑ | ☑ | ☑ | ☑ | ⌧ | ⌧ | ⌧
XML family | ⌧ | ⌧ | ⌧ | ⌧ | ⌧ | ☑ | ☑
Multiple graphs | ⌧ | ⌧ | ☑ | ☑ | ☑ | ⌧ | ⌧

##  7 RDF compression

RDF compression has been widely addressed recently. However, there is no
leading standard for RDF compression.

A recent work [64] points out that RDF datasets are highly compressible
because of the RDF graph structure and RDF syntax verbosity. In that paper,
different compression approaches are analyzed, including:

  1. 1.

direct compression,

  2. 2.

adjacency list compression,

  3. 3.

an RDF split into the element dictionaries and the statements.

The conclusions of that paper suggest that RDF is highly compressible.

######  Definition 7.1 (RDF compression processor).

An _RDF compression processor_ is used by application programs for encoding
their RDF data into compressed RDF data and/or to decode compressed RDF data
to make the data accessible. ∎

Header-Dictionary-Triples [66] (denoted hdt in Table 8), a binary format that
is based on three main parts:

  1. 1.

a header, which includes metadata describing the RDF dataset,

  2. 2.

a dictionary, which organizes all the identifiers in the graph (it provides a
list of the RDF terms such as literals, IRIs and blank nodes),

  3. 3.

a triples component, which consists of the underlying RDF graph pure
structure.

HDT achieves high levels of compression and provides retrieving features to
the compressed data. That approach works on the complete dataset, with non-
negligible processing time. That idea is extended in [63]. In that thesis, the
author proposes techniques to compress rich-functional RDF dictionaries and
triple indexing. That thesis shows the use of a succinct data configuration to
browse HDT-encoded datasets. HDT can be used as a backend of Triple Pattern
Fragments [159] is natively support fast triple-pattern extraction.

In [65, 2] (denoted eri in Table 8), authors exploit a feature of RDF data
streams, which is the regularity of their data values and structure. They
propose a compressed Efficient RDF Interchange format, which can reduce the
amount of data transmitted when processing RDF streams. ERI considers an RDF
stream as a continuous flow of blocks of triples. A standard compressor can be
used in each channel and impact on its data regularities to produce better
compression results.

Another approach is RDF Differential Stream compressor based on Zlib [67]
(denoted rdsz in Table 8), which is a proposal for RDF streaming compression.
It applies the general-purpose stream compressor Zlib to RDF streams. It uses
differential encoding to obtain structural similarities. The results of this
process are compressed with Zlib to exploit additional redundancies.
Furthermore, that approach achieves gains in compression at the cost of
increasing the processing time.

The interest on RDF compression over streaming data has been indirectly
covered by RDF stream processing systems such as Continuous Query Evaluation
over Linked Streams Cloud [98] (denoted cqels in Table 8) and Ztreamy [68]
(denoted ztr in Table 8). These papers emphasize the importance of compression
for scalable transmission of RDF streams over the network. In [98], authors
suggest an approach to deal with this issue by dictionary encoding. In [68],
authors discuss a scalable middleware for stream publishing.

Several research areas have emerged around MapReduce and RDF compression, e.g.
scalable compression of large RDF datasets [157] and large RDF data
compression and decompression efficiency [156] (denoted mr in Table 8). The
first paper presents an approach based on providing another dictionary-based
compression on top of MapReduce [53]. In the second one, authors expand [156]
and achieve linear scalability concerning the number of nodes and input size.
Another proposal is presented in [74], where HDT-MR is introduced. HDT-MR uses
MapReduce technique to process huge RDF and build the HDT serialization.

It is worth noting that EXI (Efficient XML Interchange) [91] can be used to
RDF compression but it can only serialize XML [129] i.e. RDF/XML or TriX or
JSON [116] i.e. JSON-LD. In Table 8 we present features of the above-mentioned
proposals, namely: having W3C Recommendation, binary syntax, ability to
stream, ability to scale and support of a software library used for data
compression (Zlib).

Table 8: RDF compression. This table presents the features of serializations,
namely: having W3C Recommendation (yes – ☑, no – ⌧), binary syntax (yes – ☑,
no – ⌧), ability to stream (yes – ☑, no – ⌧), ability to scale (yes – ☑, no –
⌧), and support of a software library used for data compression (yes – ☑, no –
⌧)

.  Feature hdt eri rdsz cqels ztr mr Standard ☑⋆ ⌧ ⌧ ⌧ ⌧ ⌧ Binary format ☑ ☑ ☑
☑ ☑ ☑ Streamable ⌧ ☑ ☑ ☑ ☑ ☑ Scalable ☑ ☑ ☑ ☑ ☑ ☑ Zlib ⌧ ⌧ ☑ ⌧ ☑ ☑ ⋆ W3C
Member Submission

##  8 Conclusions

Standards are instrumental in achieving a significant level of
interoperability. W3C recommendations provide people and institutions a basis
for mutual understanding. The recommendations that define RDF are used as
tools to facilitate various providers to interact with one another. Despite
the achievements of current RDF recommendations, they are not sufficient for
achieving full end-to-end interoperability. The standards leave several areas
vulnerable to variations in interpretation. In this article, we outlined
various RDF recommendations, scientific papers that extend and clarify them,
and presented a summarised formal description that we hope will clarify some
of interpretative differences.

We specifically provided insights on the interpretation of the handling of
blank nodes and reification. We presented several interpretative differences,
each corresponding to an entailment regime in a standard way. We surveyed
various RDF serializations, RDF compression proposals, and RDF mapping
approaches to highlight their differences. Finally, we presented a summarized
formal definition of RDF 1.1 and emphasized changes between RDF versions 1.0
and 1.1.

We argue that knowledge representation and data integration on the Web faces
some of the same challenges we were facing ten years ago, in spite of the
significant work being accomplished by both researchers and implementers. We
hope that this review contributes to a better understanding of RDF 1.1, and
provides the basis for a discussion of interpretative differences. We hope
some of these gaps may be able to be fixed in a future version of RDF, such as
selection of concise reification, and a formal description of the data model
that addresses practical experiences with reification, and blank nodes.

## Acknowledgements

The authors gratefully acknowledges the members of the RDF 1.1 Working Group
who defined RDF version 1.1. We thank Anna Gomolińska for comments that
greatly improved the manuscript.

## References

  * [1] Faisal Alkhateeb and Sébastien Laborie.  Towards extending and using SPARQL for modular document generation.  In Proceedings of the Eighth ACM Symposium on Document Engineering, DocEng ’08, pages 164–172, New York, NY, USA, 2008. ACM.
  * [2] Sandra Álvarez-García, Nieves R. Brisaboa, Javier D. Fernández, Miguel A. Martínez-Prieto, and Gonzalo Navarro.  Compressed Vertical Partitioning for Efficient RDF Management.  Knowledge and Information Systems, 44(2):439–474, Aug 2015.
  * [3] Bernd Amann, Catriel Beeri, Irini Fundulaki, and Michel Scholl.  Ontology-Based Integration of XML Web Resources.  In The Semantic Web — ISWC 2002, ISWC ’02, pages 117–131, Berlin, Heidelberg, 2002. Springer Berlin Heidelberg.
  * [4] Grigoris Antoniou, Paul Groth, Frank Van Harmelen, and Rinke Hoekstra.  A Semantic Web Primer, Third Edition.  MIT press, 2004.
  * [5] Irina Astrova.  Reverse Engineering of Relational Databases to Ontologies.  In The Semantic Web: Research and Applications, pages 327–341, Berlin, Heidelberg, 2004. Springer Berlin Heidelberg.
  * [6] Irina Astrova.  Rules for Mapping SQL Relational Databases to OWL Ontologies.  In MTSR, pages 415–424, Boston, MA, 2007. Springer US.
  * [7] Sören Auer, Christian Bizer, Georgi Kobilarov, Jens Lehmann, Richard Cyganiak, and Zachary Ives.  DBpedia: A Nucleus for a Web of Open Data.  In The Semantic Web, pages 722–735, Berlin, Heidelberg, 2007\. Springer Berlin Heidelberg.
  * [8] Sören Auer, Sebastian Dietzold, Jens Lehmann, Sebastian Hellmann, and David Aumueller.  Triplify: Light-weight Linked Data Publication from Relational Databases.  In Proceedings of the 18th International Conference on World Wide Web, WWW ’09, pages 621–630, New York, NY, USA, 2009. ACM.
  * [9] Jesús Barrasa, Óscar Corcho, and Asunción Gómez-pérez.  R2O, an Extensible and Semantically based Database-to-Ontology Mapping Language.  In in In Proceedings of the 2nd Workshop on Semantic Web and Databases(SWDB2004, pages 1069–1070. Springer, 2004.
  * [10] Steve Battle.  Gloze: XML to RDF and back again.  In Jena User Conference, 2006.
  * [11] Ivan Bedini, Christopher Matheus, Peter F. Patel-Schneider, Aidan Boran, and Benjamin Nguyen.  Transforming XML Schema to OWL Using Patterns.  In Proceedings of the 2011 IEEE Fifth International Conference on Semantic Computing, ICSC ’11, pages 102–109, Washington, DC, USA, 2011\. IEEE Computer Society.
  * [12] Tim Berners-Lee, Dan Connolly, and Sandro Hawke.  Semantic Web Tutorial Using N3.  In Twelfth International World Wide Web Conference, 2003.
  * [13] Diego Berrueta, Jose E Labra, and Ivan Herman.  XSLT+SPARQL: Scripting the Semantic Web with SPARQL Embedded into XSLT Stylesheets.  In 4th Workshop on Scripting for the Semantic Web, Tenerife. Citeseer, 2008.
  * [14] Nikos Bikakis, Nektarios Gioldasis, Chrisa Tsinaraki, and Stavros Christodoulakis.  Querying XML Data with SPARQL.  In Database and Expert Systems Applications, DEXA ’09, pages 372–381, Berlin, Heidelberg, 2009. Springer-Verlag.
  * [15] Mark Birbeck and Shane McCarron.  CURIE Syntax 1.0: A syntax for expressing Compact URIs.  W3C working group note, World Wide Web Consortium, 12 2010.
  * [16] Stefan Bischof, Stefan Decker, Thomas Krennwallner, Nuno Lopes, and Axel Polleres.  Mapping between RDF and XML with XSPARQL.  Journal on Data Semantics, 1(3):147–185, Sep 2012.
  * [17] Stefan Bischof, Nuno Lopes, and Axel Polleres.  Improve Efficiency of Mapping Data Between XML and RDF with XSPARQL.  In Proceedings of the 5th International Conference on Web Reasoning and Rule Systems, RR’11, pages 232–237, Berlin, Heidelberg, 2011\. Springer-Verlag.
  * [18] Christian Bizer and Andy Seaborne.  D2RQ - Treating Non-RDF Databases as Virtual RDF Graphs.  In ISWC2004 (posters), 11 2004.
  * [19] Hannes Bohring and Sören Auer.  Mapping XML to OWL Ontologies.  Leipziger Informatik-Tage, 72:147–156, 2005.
  * [20] David Booth.  Well Behaved RDF: A Straw-Man Proposal for Taming Blank Nodes, 2014\.
  * [21] Tim Bray, Dave Hollander, Andrew Layman, and Richard Tobin.  Namespaces in XML 1.1 (Second Edition).  W3C recommendation, World Wide Web Consortium, 4 2006.
  * [22] Dan Brickley and Ramanathan Guha.  RDF Schema 1.1.  W3C recommendation, World Wide Web Consortium, 2 2014.
  * [23] Dan Brickley and Libby Miller.  FOAF Vocabulary Specification 0.99.  Technical report, FOAF Project, 1 2014.
  * [24] Agustina Buccella, Miguel R Penabad, Francisco J Rodriguez, A Farina, and Alejandra Cechich.  From relational databases to OWL ontologies.  In Proceedings of the 6th National Russian Research Conference, 2004.
  * [25] Guntars Būmans and Kārlis Čerāns.  RDB2OWL: A Practical Approach for Transforming RDB Data into RDF/OWL.  In Proceedings of the 6th International Conference on Semantic Systems, I-SEMANTICS ’10, pages 25:1–25:3, New York, NY, USA, 2010. ACM.
  * [26] Peter Buneman and Egor Kostylev.  Annotation algebras for RDFS.  In The Second International Workshop on the role of Semantic Web in Provenance Management (SWPM-10), CEUR Workshop Proceedings, page 32, 2010\.
  * [27] Kate Byrne.  Having Triplets – Holding Cultural Data as RDF.  In Proceedings of the ECDL 2008 Workshop on Information Access to Cultural Heritage, Aarhus, Denmark, 9 2008.
  * [28] Diego Calvanese, Giuseppe De Giacomo, Domenico Lembo, Maurizio Lenzerini, Antonella Poggi, Mariano Rodriguez-Muro, Riccardo Rosati, Marco Ruzzi, and Domenico Fabio Savo.  The MASTRO System for Ontology-based Data Access.  Semantic Web, 2(1):43–53, 1 2011.
  * [29] Gavin Carothers.  RDF 1.1 N-Quads.  W3C recommendation, World Wide Web Consortium, 2 2014.
  * [30] Gavin Carothers and Andy Seaborne.  RDF 1.1 N-Triples.  W3C recommendation, World Wide Web Consortium, 2 2014.
  * [31] Jeremy J. Carroll.  Matching RDF Graphs.  In The Semantic Web — ISWC 2002, pages 5–15, Berlin, Heidelberg, 2002. Springer Berlin Heidelberg.
  * [32] Jeremy J Carroll, Christian Bizer, Pat Hayes, and Patrick Stickler.  Named Graphs, Provenance and Trust.  In Proceedings of the 14th International Conference on World Wide Web, WWW ’05, pages 613–622, New York, NY, USA, 2005. ACM.
  * [33] Jeremy J Carroll and Patrick Stickler.  RDF triples in XML.  In Proceedings of the 13th International World Wide Web Conference on Alternate Track Papers & Posters, WWW Alt. ’04, pages 412–413, New York, NY, USA, 2004. ACM.
  * [34] Farid Cerbah.  Learning Highly Structured Semantic Repositories from Relational Databases: The RDBToOnto Tool.  In The Semantic Web: Research and Applications, ESWC’08, pages 777–781, Berlin, Heidelberg, 2008. Springer-Verlag.
  * [35] Farid Cerbah.  Mining the Content of Relational Databases to Learn Ontologies with Deeper Taxonomies.  In Web Intelligence, volume 1, pages 553–557. IEEE Computer Society, Dec 2008.
  * [36] Stefano Ceri, Letizia Tanca, and Roberto V. Zicari.  Supporting Interoperability Between New Database Languages.  In Proc. of the 5th Annual European Computer Conference (CompEuro), pages 273–281, 5 1991.
  * [37] Pierre-Antoine Champin.  RDF tutorial, 2001.
  * [38] Lei Chen, Haifei Zhang, Ying Chen, and Wenping Guo.  Blank Nodes in RDF.  Journal of Software, 7(9):1993–1999, 2012.
  * [39] Roberto Chinnici, Jean-Jacques Moreau, Arthur Ryman, and Sanjiva Weerawarana.  Web Services Description Language (WSDL) Version 2.0 Part 1: Core Language.  W3C recommendation, World Wide Web Consortium, 6 2007.
  * [40] Dan Connolly.  Gleaning Resource Descriptions from Dialects of Languages (GRDDL).  W3C recommendation, World Wide Web Consortium, 9 2007.
  * [41] Olivier Corby and Catherine Faron-Zucker.  A Transformation Language for RDF based on SPARQL.  In Web Information Systems and Technologies, pages 318–340, Cham, 2016. Springer International Publishing.
  * [42] Olivier Corby, Catherine Faron-Zucker, and Fabien Gandon.  A Generic RDF Transformation Software and Its Application to an Online Translation Service for Common Languages of Linked Data.  In International Semantic Web Conference (2), volume 9367 of Lecture Notes in Computer Science, pages 150–165. Springer, 2015.
  * [43] Christophe Cruz and Christophe Nicolle.  Ontology Enrichment and Automatic Population From XML Data.  In Proceedings of the 4th International VLDB Workshop on Ontology-based Techniques for DataBases in Information Systems and Knowledge Systems, ODBIS 2008, pages 17–20, Auckland, New Zealand, 8 2008.
  * [44] David Crystal.  The Cambridge Encyclopedia of Language (3rd edition).  Cambridge University Press, 11 2018.
  * [45] Olivier Curé and Guillaume Blin.  RDF database systems: triples storage and SPARQL query processing.  Morgan Kaufmann, 2014.
  * [46] Carlo Curino, Giorgio Orsi, Emanuele Panigati, and Letizia Tanca.  Accessing and Documenting Relational Databases Through OWL Ontologies.  In Proceedings of the 8th International Conference on Flexible Query Answering Systems, FQAS ’09, pages 431–442, Berlin, Heidelberg, 2009\. Springer-Verlag.
  * [47] Richard Cyganiak, Markus Lanthaler, and David Wood.  RDF 1.1 Concepts and Abstract Syntax.  W3C recommendation, World Wide Web Consortium, 2 2014.
  * [48] Souripriya Das, Richard Cyganiak, and Seema Sundara.  R2RML: RDB to RDF Mapping Language.  W3C recommendation, World Wide Web Consortium, 9 2012.
  * [49] CJ Data.  An Introduction to Database Systems.  Addison-Wesley publ., 1975.
  * [50] Jos J. de Bruijn, Enrico Franconi, and Sergio Tessaris.  Logical Reconstruction of RDF and Ontology Languages.  In Principles and Practice of Semantic Web Reasoning, pages 65–71, Berlin, Heidelberg, 2005. Springer Berlin Heidelberg.
  * [51] Cristian Pérez De Laborda and Stefan Conrad.  Querying Relational Databases with RDQL.  In Berliner XML Tage, pages 161–172. Citeseer, 2005.
  * [52] Cristian Pérez de Laborda and Stefan Conrad.  Relational.OWL: A Data and Schema Representation Format Based on OWL.  In Proceedings of the 2Nd Asia-Pacific Conference on Conceptual Modelling - Volume 43, APCCM ’05, pages 89–96, Darlinghurst, Australia, Australia, 2005. Australian Computer Society, Inc.
  * [53] Jeffrey Dean and Sanjay Ghemawat.  MapReduce: Simplified Data Processing on Large Clusters.  Communications of the ACM, 51(1):107–113, 2008.
  * [54] Stefan Decker, Prasenjit Mitra, and Sergey Melnik.  Framework for the Semantic Web: an RDF Tutorial.  IEEE Internet Computing, 4(6):68–73, Nov 2000.
  * [55] Davy Van Deursen, Chris Poppe, Gäetan Martens, Erik Mannens, and Rik Van de Walle.  XML to RDF Conversion: A Generic Approach.  In Proceedings of the 2008 International Conference on Automated Solutions for Cross Media Content and Multi-channel Distribution, AXMEDIS ’08, pages 138–144, Washington, DC, USA, 11 2008. IEEE Computer Society.
  * [56] Anastasia Dimou, Miel Vander Sande, Pieter Colpaert, Ruben Verborgh, Erik Mannens, and Rik Van de Walle.  RML: A Generic Language for Integrated RDF Mappings of Heterogeneous Data.  In Proceedings of the 7th Workshop on Linked Data on the Web, volume 1184 of CEUR Workshop Proceedings, 4 2014.
  * [57] Matthias Droop, Markus Flarer, Jinghua Groppe, Sven Groppe, Volker Linnemann, Jakob Pinggera, Florian Santner, Michael Schier, Felix Schöpf, Hannes Staffler, et al.  Bringing the XML and Semantic Web Worlds Closer: Transforming XML into RDF and embedding XPath into SPARQL.  In Enterprise Information Systems, pages 31–45. Springer Berlin Heidelberg, Berlin, Heidelberg, 2009.
  * [58] Orri Erling and Ivan Mikhailov.  RDF Support in the Virtuoso DBMS.  In Networked Knowledge - Networked Media: Integrating Knowledge Management, New Media Technologies and Semantic Systems, pages 7–24, Berlin, Heidelberg, 2009. Springer Berlin Heidelberg.
  * [59] Orri Erling and Ivan Mikhailov.  RDF Support in the Virtuoso DBMS.  In Networked Knowledge-Networked Media, pages 7–24. Springer, 2009.
  * [60] Joel Farrell and Holger Lausen.  Semantic Annotations for WSDL and XML Schema.  W3C recommendation, World Wide Web Consortium, 8 2007.
  * [61] Lee Feigenbaum, Ivan Herman, Tonya Hongsermeier, Eric Neumann, and Susie Stephens.  The Semantic Web in Action.  Scientific American, 297(6):90–97, 2007.
  * [62] Matthias Ferdinand, Christian Zirpins, and David Trastour.  Lifting XML schema to OWL.  In Web Engineering, pages 354–358. Springer Berlin Heidelberg, Berlin, Heidelberg, 2004.
  * [63] Javier D. Fernández.  Binary RDF for Scalable Publishing, Exchanging and Consumption in the Web of Data.  In Proceedings of the 21st International Conference on World Wide Web, WWW ’12 Companion, pages 133–138, New York, NY, USA, 2012. ACM.
  * [64] Javier D. Fernández, Claudio Gutierrez, and Miguel A. Martínez-Prieto.  RDF Compression: Basic Approaches.  In Proceedings of the 19th International Conference on World Wide Web, WWW ’10, pages 1091–1092, New York, NY, USA, 2010. ACM.
  * [65] Javier D. Fernández, Alejandro Llaves, and Oscar Corcho.  Efficient RDF Interchange (ERI) Format for RDF Data Streams.  In The Semantic Web – ISWC 2014, pages 244–259, Cham, 2014. Springer International Publishing.
  * [66] Javier D Fernández, Miguel A Martínez-Prieto, Claudio Gutiérrez, Axel Polleres, and Mario Arias.  Binary RDF Representation for Publication and Exchange (HDT).  Journal of Web Semantics, 19:22–41, 2013.
  * [67] Norberto Fernández, Jesús Arias, Luis Sánchez, Damaris Fuentes-Lorenzo, and Óscar Corcho.  RDSZ: An approach for lossless RDF stream compression.  In The Semantic Web: Trends and Challenges, pages 52–67, Cham, 2014. Springer International Publishing.
  * [68] Jesus Arias Fisteus, Norberto Fernández Garcia, Luis Sánchez Fernandez, and Damaris Fuentes-Lorenzo.  Ztreamy: A middleware for publishing semantic streams on the Web.  Journal of Web Semantics, 25:16–23, 2014.
  * [69] Enrico Franconi, Jos de Bruijn, and Sergio Tessaris.  Logical Reconstruction of Normative RDF.  In OWLED, volume 188 of CEUR Workshop Proceedings. CEUR-WS.org, 2005.
  * [70] Fabien Gandon and Guus Schreiber.  RDF 1.1 XML Syntax.  W3C recommendation, World Wide Web Consortium, 2 2014.
  * [71] Roberto Garcia and Oscar Celma.  Semantic Integration and Retrieval of Multimedia Metadata.  In 5th International Workshop on Knowledge Markup and Semantic Annotation, pages 69–80, 2005.
  * [72] Raji Ghawi and Nadine Cullot.  Database-to-Ontology Mapping Generation for Semantic Interoperability.  In Third International Workshop on Database Interoperability (InterDB 2007), 09 2007.
  * [73] Raji Ghawi and Nadine Cullot.  Building Ontologies from XML Data Sources.  In Proceedings of the 2009 20th International Workshop on Database and Expert Systems Application, DEXA ’09, pages 480–484, Washington, DC, USA, Aug 2009. IEEE Computer Society.
  * [74] José M Giménez-García, Javier D Fernández, and Miguel A Martínez-Prieto.  HDT-MR: A scalable solution for RDF compression with HDT and MapReduce.  In The Semantic Web. Latest Advances and New Domains, pages 253–268, Cham, 2015. Springer International Publishing.
  * [75] Bernardo Cuenca Grau.  A Possible Simplification of the Semantic Web Architecture.  In Proceedings of the 13th International Conference on World Wide Web, WWW ’04, pages 704–713, New York, NY, USA, 2004. ACM.
  * [76] Paul Groth, Andrew Gibson, and Jan Velterop.  The anatomy of a Nano-publication.  Information Services and Use, 30(1-2):51–56, 2010.
  * [77] Claudio Gutierrez, Carlos Hurtado, and Alejandro Vaisman.  Temporal RDF.  In The Semantic Web: Research and Applications, pages 93–107. Springer Berlin Heidelberg, Berlin, Heidelberg, 2005.
  * [78] Claudio Gutierrez, Carlos A. Hurtado, and Alberto O. Mendelzon.  Foundations of Semantic Web Databases.  In ACM Symposium on Principles of Database Systems (PODS), pages 95–106, 2004.
  * [79] Claudio Gutierrez, Carlos A. Hurtado, Alberto O. Mendelzon, and Pérez Jorge.  Foundations of Semantic Web Databases.  Journal of Computer and System Sciences, 77(3):520–541, 2011.  Database Theory.
  * [80] Steven Harris and Andy Seaborne.  SPARQL 1.1 Query Language.  W3C recommendation, World Wide Web Consortium, 3 2013.
  * [81] Andreas Harth, Katja Hose, and Ralf Schenkel.  Linked Data Management.  CRC Press, 2014.
  * [82] Olaf Hartig and Bryan Thompson.  Foundations of an Alternative Approach to Reification in RDF.  CoRR, abs/1406.3399, 2014.
  * [83] Patrick Hayes.  RDF 1.1 Semantics.  W3C recommendation, World Wide Web Consortium, 2 2014.
  * [84] Matthias Hert, Gerald Reif, and Harald C. Gall.  Updating Relational Data via SPARQL/Update.  In Proceedings of the 2010 EDBT/ICDT Workshops, EDBT ’10, pages 24:1–24:8, New York, NY, USA, 2010. ACM.
  * [85] Pascal Hitzler, Markus Krotzsch, and Sebastian Rudolph.  Foundations of Semantic Web Technologies.  Chapman & Hall/CRC, 1st edition, 2011.
  * [86] Aidan Hogan.  Skolemising Blank Nodes While Preserving Isomorphism.  In Proceedings of the 24th International Conference on World Wide Web, WWW ’15, pages 430–440, Republic and Canton of Geneva, Switzerland, 2015. International World Wide Web Conferences Steering Committee.
  * [87] Aidan Hogan.  Skolemising Blank Nodes while Preserving Isomorphism.  In Proceedings of the 24th International Conference on World Wide Web, WWW ’15, pages 430–440, Republic and Canton of Geneva, Switzerland, 2015. International World Wide Web Conferences Steering Committee.
  * [88] Aidan Hogan, Marcelo Arenas, Alejandro Mallea, and Axel Polleres.  Everything You Always Wanted to Know About Blank Nodes.  Journal of Web Semantics, 27-28:42–69, 2014.  Semantic Web Challenge 2013.
  * [89] Ian Horrocks, Peter F. Patel-Schneider, and Frank Van Harmelen.  Reviewing the Design of DAML+OIL: An Ontology Language for the Semantic Web.  In Eighteenth National Conference on Artificial Intelligence, pages 792–797, Menlo Park, CA, USA, 2002. American Association for Artificial Intelligence.
  * [90] Wei Hu and Yuzhong Qu.  Discovering Simple Mappings Between Relational Database Schemas and Ontologies.  In The Semantic Web, pages 225–238, Berlin, Heidelberg, 2007\. Springer Berlin Heidelberg.
  * [91] Sebastian Käbisch, Daniel Peintner, and Darko Anicic.  Standardized and Efficient RDF Encoding for Constrained Embedded Networks.  In The Semantic Web. Latest Advances and New Domains, pages 437–452, Cham, 2015. Springer International Publishing.
  * [92] Michael Kay.  XSL Transformations (XSLT) Version 3.0.  W3C recommendation, World Wide Web Consortium, 6 2017.
  * [93] Michael Kifer and Georg Lausen.  F-logic: a Higher-order Language for Reasoning About Objects, Inheritance, and Scheme.  SIGMOD Rec., 18(2):134–146, 6 1989.
  * [94] Michel C. A. Klein.  Interpreting XML Documents via an RDF Schema Ontology.  In Proceedings of the 13th International Workshop on Database and Expert Systems Applications, DEXA ’02, pages 889–894, Washington, DC, USA, Sep 2002. IEEE Computer Society.
  * [95] Ioanna Koffina, Giorgos Serfiotis, Vassilis Christophides, and Val Tannen.  Mediating RDF/S Queries to Relational and XML Sources.  International Journal on Semantic Web and Information Systems, 2(4):68, 2006.
  * [96] Manolis Koubarakis and Kostis Kyzirakos.  Modeling and Querying Metadata in the Semantic Sensor Web: The Model stRDF and the Query Language stSPARQL.  In ESWC (1), volume 6088 of Lecture Notes in Computer Science, pages 425–439. Springer, 2010.
  * [97] Ora Lassila and Ralph R. Swick.  Resource Description Framework (RDF) Model and Syntax Specification.  W3C recommendation, World Wide Web Consortium, 2 1999.
  * [98] Danh Le-Phuoc, Hoan Nguyen Mau Quoc, Chan Le Van, and Manfred Hauswirth.  Elastic and Scalable Processing of Linked Stream Data in the Cloud.  In The Semantic Web – ISWC 2013, pages 280–297, Berlin, Heidelberg, 2013. Springer Berlin Heidelberg.
  * [99] Patrick Lehti and Peter Fankhauser.  XML Data Integration with OWL: Experiences and Challenges.  In Applications and the Internet, 2004. Proceedings. 2004 International Symposium on, pages 160–167. IEEE, Jan 2004.
  * [100] Maurizio Lenzerini.  Data Integration: A Theoretical Perspective.  In Proceedings of the Twenty-first ACM SIGMOD-SIGACT-SIGART Symposium on Principles of Database Systems, PODS ’02, pages 233–246, New York, NY, USA, 2002. ACM.
  * [101] Man Li, Xiaoyong Du, and Shan Wang.  A Semi-automatic Ontology Acquisition Method for the Semantic Web.  In Advances in Web-Age Information Management, WAIM’05, pages 209–220, Berlin, Heidelberg, 2005. Springer-Verlag.
  * [102] Nuno Lopes, Stefan Bischof, Stefan Decker, and Axel Polleres.  On the Semantics of Heterogeneous Querying of Relational, XML and RDF Data with XSPARQL.  In Proceedings of the 15th Portuguese Conference on Artificial Intelligence (EPIA 2011), Lisbon, Portugal, 2011.
  * [103] Alejandro Mallea, Marcelo Arenas, Aidan Hogan, and Axel Polleres.  On Blank Nodes.  In The Semantic Web – ISWC 2011, pages 421–437, Berlin, Heidelberg, 2011. Springer Berlin Heidelberg.
  * [104] Frank Manola and Eric Miller.  RDF Primer.  W3C recommendation, World Wide Web Consortium, 2 2004.
  * [105] Draltan Marin.  A formalization of RDF.  Master’s thesis, École Polytechnique, 8 2004.
  * [106] Shane McCarron, Ben Adida, Mark Birbeck, and Ivan Herman.  RDFa Core 1.1 - Third Edition.  W3C recommendation, World Wide Web Consortium, 8 2015.
  * [107] Sergio Muñoz, Jorge Pérez, and Claudio Gutierrez.  Minimal Deductive Systems for RDF.  In The Semantic Web: Research and Applications, pages 53–67, Berlin, Heidelberg, 2007. Springer Berlin Heidelberg.
  * [108] Sergio Munoz, Jorge Perez, and Claudio Gutierrez.  Simple and Efficient Minimal RDFS.  Web Semant., 7(3):220–234, 9 2009.
  * [109] Vinh Nguyen, Olivier Bodenreider, and Amit Sheth.  Don’t Like RDF Reification?: Making Statements About Statements Using Singleton Property.  In Proceedings of the 23rd International Conference on World Wide Web, WWW ’14, pages 759–770, New York, NY, USA, 2014. ACM.
  * [110] Mark Nottingham and Eran Hammer-Lahav.  Defining Well-Known Uniform Resource Identifiers (URIs).  RFC 5785, Internet Engineering Task Force, 4 2010.
  * [111] Natasha Noy and Alan Rector.  Defining N-ary Relations on the Semantic Web.  W3C working group note, World Wide Web Consortium, 4 2006.
  * [112] Csongor Nyulas, Martin OConnor, and Samson Tu.  DataMaster–a plug-in for importing schemas and data from relational databases into Protege.  In Proceedings of the 10th International Protege Conference. Citeseer, 2007.
  * [113] Martin J O’Connor and Amar Das.  Acquiring OWL Ontologies from XML Documents.  In Proceedings of the Sixth International Conference on Knowledge Capture, K-CAP ’11, pages 17–24, New York, NY, USA, 2011. ACM.
  * [114] Jeff Z. Pan and Ian Horrocks.  RDFS(FA) and RDF MT: Two semantics for RDFS.  In The Semantic Web - ISWC 2003, pages 30–46, Berlin, Heidelberg, 2003. Springer Berlin Heidelberg.
  * [115] Peter Patel-Schneider and Patrick Hayes.  RDF 1.1 Semantics.  W3C recommendation, World Wide Web Consortium, 2 2014.
  * [116] Daniel Peintner and Don Brutzman.  EXI for JSON (EXI4JSON).  W3C working group note, World Wide Web Consortium, 4 2018.
  * [117] Silvio Peroni and Fabio Vitali.  RSLT: RDF Stylesheet Language Transformations.  In ESWC Developers Workshop, volume 1361 of CEUR Workshop Proceedings, pages 7–13. CEUR-WS.org, 2015.
  * [118] Reinhard Pichler, Axel Polleres, Fang Wei, and Stefan Woltran.  dRDF: Entailment for Domain-restricted RDF.  In The Semantic Web: Research and Applications, pages 200–214, Berlin, Heidelberg, 2008. Springer Berlin Heidelberg.
  * [119] Simeon Polfliet and Ryutaro Ichise.  Automated Mapping Generation for Converting Databases into Linked Data.  In ISWC Posters&Demos, volume 658 of CEUR Workshop Proceedings. CEUR-WS.org, 2010.
  * [120] Freddy Priyatna, Raúl Alonso-Calvo, Sergio Paraiso-Medina, Gueton Padron-Sanchez, and Oscar Corcho.  R2RML-based Access and Querying to Relational Clinical Data with Morph-RDB.  In SWAT4LS, pages 142–151, 2015.
  * [121] Eric Prud’hommeaux and Gavin Carothers.  RDF 1.1 Turtle.  W3C recommendation, World Wide Web Consortium, 2 2014.
  * [122] Dennis Quan and David R. Karger.  Xenon: An RDF Stylesheet Ontology.  Procs of WWW, page 40, 2005.
  * [123] Yves Raimond and Guus Schreiber.  RDF 1.1 Primer.  W3C note, World Wide Web Consortium, 2 2014.
  * [124] Gerald Reif, Mehdi Jazayeri, and Harald Gall.  Towards Semantic Web Engineering: WEESA-Mapping XML Schema to Ontologies.  In WWW Workshop on Application Design, Development and Implementation Issues in the Semantic Web, 2004.
  * [125] Jonathan Robie and Michael Dyck.  XQuery 3.1: An XML Query Language.  W3C recommendation, World Wide Web Consortium, 3 2017.
  * [126] Toni Rodrigues, Pedro Rosa, and Jorge Cardoso.  Moving from Syntactic to Semantic Organizations Using JXML2OWL.  Comput. Ind., 59(8):808–819, 10 2008.
  * [127] Satya S. Sahoo, Olivier Bodenreider, Joni L. Rutter, Karen J. Skinner, and Amit P. Sheth.  An Ontology-driven Semantic Mashup of Gene and Biological Pathway Information: Application to the Domain of Nicotine Dependence.  J. of Biomedical Informatics, 41(5):752–765, 10 2008.
  * [128] Percy E. Salas, Karin K. Breitman, José Viterbo F., and Marco A. Casanova.  Interoperability by Design Using the StdTrip Tool: An a Priori Approach.  In Proceedings of the 6th International Conference on Semantic Systems, I-SEMANTICS ’10, pages 43:1–43:3, New York, NY, USA, 2010. ACM.
  * [129] John Schneider, Takuki Kamiya, Daniel Peintner, and Rumen Kyusakov.  Efficient XML Interchange (EXI) Format 1.0 (Second Edition).  W3C recommendation, World Wide Web Consortium, 2 2014.
  * [130] Rolf Schwitter, Marc Tilbrook, et al.  Controlled Natural Language Meets the Semantic Web.  In Proceedings of the Australasian Language Technology Workshop, volume 2, pages 55–62. Australian Speech Science and Technology Association, 2004.
  * [131] Andy Seaborne and Gavin Carothers.  RDF 1.1 TriG.  W3C recommendation, World Wide Web Consortium, 2 2014.
  * [132] Andy Seaborne, Damian Steer, and Stuart Williams.  SQL-RDF.  http://www.w3.org/2007/03/RdfRDB/papers/seaborne.html, October 2007.
  * [133] Juan F Sequeda and Daniel P Miranker.  Ultrawrap Mapper: A Semi-Automatic Relational Database to RDF (RDB2RDF) Mapping Tool.  In International Semantic Web Conference (Posters & Demos), 2015\.
  * [134] Juan F Sequeda, Syed H Tirmizi, Oscar Corcho, and Daniel P Miranker.  Direct mapping SQL Databases to the Semantic Web: A Survey.  Univeristy of Texas, Department of Computer Sciecnces Technical Report TR-09-04, 2009.
  * [135] Pavel Shapkin and Leonid Shumsky.  A Language for Transforming the RDF Data on the Basis of Ontologies.  In Proceedings of the 11th International Conference on Web Information Systems and Technologies, pages 504–511, 2015.
  * [136] Guohua Shen, Zhiqiu Huang, Xiaodong Zhu, and Xiaofei Zhao.  Research on the Rules of Mapping from Relational Model to OWL.  In OWLED, volume 216 of CEUR Workshop Proceedings. CEUR-WS.org, 2006.
  * [137] John Snelson, Don Chamberlin, Michael Dyck, and Jonathan Robie.  XML Path Language (XPath) 3.1.  W3C recommendation, World Wide Web Consortium, 3 2017.
  * [138] John F. Sowa.  Knowledge Representation: Logical, Philosophical, and Computational Foundations.  Brooks/Cole Publishing Co., Pacific Grove, CA, USA, 2000.
  * [139] Dimitrios-Emmanuel Spanos, Periklis Stavrou, and Nikolas Mitrou.  Bringing Relational Databases into the Semantic Web: A Survey.  Semantic Web, 3(2):169–209, 4 2012.
  * [140] Michael Sperberg-McQueen, Henry Thompson, David Peterson, Ashok Malhotra, Paul V. Biron, and Sandy Gao.  W3C XML Schema Definition Language (XSD) 1.1 Part 2: Datatypes.  W3C recommendation, World Wide Web Consortium, 4 2012.
  * [141] Manu Sporny, Markus Lanthaler, and Gregg Kellogg.  JSON-LD 1.0.  W3C recommendation, World Wide Web Consortium, 1 2014.
  * [142] Ioannis Stavrakantonakis, Chrisa Tsinaraki, Nikos Bikakis, Nektarios Gioldasis, and Stavros Christodoulakis.  SPARQL2XQuery 2.0: Supporting Semantic-based queries over XML data.  In SMAP, pages 76–84. IEEE, 2010.
  * [143] Ljiljana Stojanovic, Nenad Stojanovic, and Raphael Volz.  Migrating Data-intensive Web Sites into the Semantic Web.  In Proceedings of the 2002 ACM Symposium on Applied Computing, SAC ’02, pages 1100–1107, New York, NY, USA, 2002. ACM.
  * [144] Umberto Straccia.  A minimal deductive system for general fuzzy RDF.  In Web Reasoning and Rule Systems, pages 166–181. Springer Berlin Heidelberg, Berlin, Heidelberg, 2009.
  * [145] Jeremy Tandy, Ivan Herman, and Gregg Kellogg.  Generating RDF from Tabular Data on the Web.  W3C recommendation, World Wide Web Consortium, 12 2015.
  * [146] Herman J. ter Horst.  Completeness, Decidability and Complexity of Entailment for RDF Schema and a Semantic Extension Involving the OWL Vocabulary.  Journal of Web Semantics, 3(2):79–115, 2005.  Selcted Papers from the International Semantic Web Conference, 2004.
  * [147] Harsh Thakkar, Renzo Angles, Dominik Tomaszuk, and Jens Lehmann.  Direct Mappings between RDF and Property Graph Databases.  arXiv, 2019.
  * [148] Pham Thi Thuy, Young-Koo Lee, and Sungyoung Lee.  A Semantic Approach for Transforming XML Data into RDF Ontology.  Wirel. Pers. Commun., 73(4):1387–1402, 12 2013.
  * [149] Pham Thi Thu Thuy, Young-Koo Lee, and SungYoung Lee.  DTD2OWL: Automatic Transforming XML Documents into OWL Ontology.  In Proceedings of the 2Nd International Conference on Interaction Sciences: Information Technology, Culture and Human, ICIS ’09, pages 125–131, New York, NY, USA, 2009. ACM.
  * [150] Syed Hamid Tirmizi, Juan Sequeda, and Daniel Miranker.  Translating SQL Applications to the Semantic Web.  In Database and Expert Systems Applications, DEXA ’08, pages 450–464, Berlin, Heidelberg, 2008. Springer Berlin Heidelberg.
  * [151] Dominik Tomaszuk.  Flat triples approach to RDF graphs in JSON.  In W3C Workshop – RDF Next Steps. World Wide Web, 2010.
  * [152] Dominik Tomaszuk.  Named graphs in RDF/JSON serialization.  Zeszyty Naukowe Politechniki Gdańskiej, pages 273–278, 2011\.
  * [153] Dominik Tomaszuk, Karol Pak, and Henryk Rybinski.  Trust in RDF Graphs.  In ADBIS (2), volume 186 of Advances in Intelligent Systems and Computing, pages 273–283. Springer, 2012.
  * [154] Chrisa Tsinaraki and Stavros Christodoulakis.  Interoperability of XML Schema Applications with OWL Domain Knowledge and Semantic Web Tools.  In Proceedings of the 2007 OTM Confederated International Conference on On the Move to Meaningful Internet Systems: CoopIS, DOA, ODBASE, GADA, and IS - Volume Part I, OTM’07, pages 850–869, Berlin, Heidelberg, 2007. Springer-Verlag.
  * [155] Octavian Udrea, Diego Reforgiato Recupero, and V. S. Subrahmanian.  Annotated RDF.  In Proceedings of the 3rd European Conference on The Semantic Web: Research and Applications, ESWC’06, pages 487–501, Berlin, Heidelberg, 2006. Springer-Verlag.
  * [156] Jacopo Urbani, Jason Maassen, and Henri Bal.  Massive Semantic Web Data Compression with MapReduce.  In Proceedings of the 19th ACM International Symposium on High Performance Distributed Computing, HPDC ’10, pages 795–802, New York, NY, USA, 2010. ACM.
  * [157] Jacopo Urbani, Jason Maassen, Niels Drost, Frank Seinstra, and Henri Bal.  Scalable RDF data compression with MapReduce.  Concurrency and Computation: Practice and Experience, 25(1):24–39, 2013.
  * [158] Konstantinos N. Vavliakis, Theofanis K. Grollios, and Pericles A. Mitkas.  RDOTE - Publishing Relational Databases into the Semantic Web.  J. Syst. Softw., 86(1):89–99, 1 2013.
  * [159] Ruben Verborgh, Olaf Hartig, Ben De Meester, Gerald Haesendonck, Laurens De Vocht, Miel Vander Sande, Richard Cyganiak, Pieter Colpaert, Erik Mannens, and Rik Van de Walle.  Querying Datasets on the Web with High Availability.  In The Semantic Web – ISWC 2014, pages 180–196, Cham, 2014. Springer International Publishing.
  * [160] Zhaohui Wu, Huajun Chen, Heng Wang, Yimin Wang, Yuxin Mao, Jinmin Tang, and Cunyin Zhou.  Dartgrid: a Semantic Web Toolkit for Integrating Heterogeneous Relational Databases.  In Semantic Web Challenge at 4th International Semantic Web Conference, Athens, USA, 11 2006.
  * [161] Huiyong Xiao and Isabel F Cruz.  Integrating and Exchanging XML Data Using Ontologies.  In Journal on Data Semantics VI, pages 67–89, Berlin, Heidelberg, 2006. Springer Berlin Heidelberg.
  * [162] Nora Yahia, Sahar A. Mokhtar, and Amr Ahmed.  Automatic Generation of OWL Ontology from XML Data Source.  CoRR, abs/1206.0570, 2012.
  * [163] Guizhen Yang and Michael Kifer.  Reasoning about Anonymous Resources and Meta Statements on the Semantic Web.  J. Data Semantics, 1:69–97, 2003.
  * [164] Antoine Zimmermann.  RDF 1.1: On Semantics of RDF Datasets.  W3C note, World Wide Web Consortium, 2 2014.
  * [165] Antoine Zimmermann, Nuno Lopes, Axel Polleres, and Umberto Straccia.  A General Framework for Representing, Reasoning and Querying with Annotated Semantic Web Data.  Journal of Web Semantics, 11:72–95, 2012.