Linked Open Data (LOD) sources on the Web are increasingly becoming more popular. RDF constraints can be used to characterize the RDF graphs being provided by such sources. For applications that process data retrieved from several of such RDF graphs it becomes interesting to analyze the relationships of the di erent sets of constraints associated with the sources providing the RDF graphs. In this short paper we discuss how the constraints from di erent sources can be aggregated to a set of constraints characterizing the union of the RDF graphs under consideration. For expressing constraints we use Datalog+/-.
The recent RDF Validation Workshop [
The intention of an RDD is similar to Stardog ICV [
While in [
Let us consider RDF graphs Ga and Gb and corresponding RDDs RDDa and RDDb, respectively. Both graphs are assumed to be consistent, i.e. all the constraints in the respective RDD are ful lled. The main question we are interested in is how the union of the graphs Ga [ Gb is related to the union of the respective sets of constraints a and b. As Ga and Gb may contain triples referring to subjects with the same URI, in general it will hold Ga [ Gb does not ful ll all constraints in a [ b. For example, whenever a certain predicate p is de ned to be single-valued in RDDa and RDDb, then two corresponding triples (s; p; o1) and (s; p; o2) may appear in the union Ga [ Gb of both graphs, so that the constraint is not guaranteed to hold in Ga [ Gb. As solution for such cases we propose aggregation of constraints what in our example would mean that the single-valued constraint is replaced by a constraint restricting the number of occurrences of values to 2. In general, given RDDs a and b, we are interested to construct an RDD ( a; b) such that for any RDF graphs Ga and Gb, where Ga j= a and Gb j= b, we have Ga j= ( a; b), Gb j= ( a; b) and Ga[Gb j= ( a; b). The task of deriving ( a; b) is called constraint aggregation.
Recently, Cortes-Calabuig and Paredaens [
In Figure 1 we exhibit two RDDs describing RDF graphs representing employees and projects. To demonstrate constraint aggregation let us consider predicate reportsTo, which is de ned via a path-constraint in RDDa. In RDDb for reportsTo it is de ned that each employee must report to exactly two objects. These constraints are written in Datalog+/as follows (predicate names are abbreviated):
G($s; rT; $o) ! 9$o1(G($s; wF; $o1); G($o1; aT; $o)) G($s; rT; $o1); G($s; rT; $o2); G($s; rT; $o3) ! $o1 = $o2 _ $o1 = $o3 _ $o2 = $o3 G($s; type; E) ! 9$o1; o2(G($s; rT; $o1); G($s; rT; $o2); $o1 6= $o2) Moreover, RDDa de nes worksFor and assignedTo as total functions. Therefore it can be inferred that reportsTo is a partial function, even though this is not stated in RDDa. Using this additional information, PREFIX ex: <http://www.example.com#> CWA CLASS ex:Employee {
KEY rdfs:label : LITERAL PARTIAL ex:employedBy : RESOURCE MAX(2) ex:prevEmployedBy : RESOURCE TOTAL ex:worksFor, RANGE (ex:Project) PATH(ex:worksFor/ex:assignedTo) ex:reportsTo, RANGE(ex:Consortium) }
PREFIX ex: <http://www.example.com#> CWA CLASS ex:Employee {
KEY rdfs:label : LITERAL PARTIAL ex:employedBy : RESOURCE ex:prevEmployedBy : RESOURCE,
SUBPROPERTY employedBy MIN(2), MAX(2) ex:reportsTo,
RANGE(ex:Association) } CWA CLASS ex:Project {
TOTAL ex:assignedTo,
RANGE(ex:Consortium) }
by constraint aggregation we get a min(0)- and max(3)-constraint for
predicate reportsTo. Note that without the inferred constraint,
predicate reportsTo has to be considered to be unrestricted and therefore
only the trivial constraint max(1) can be derived by constraint
aggregation. Formally, inferring constraints in the Datalog+/- framework can
be done based on the chase procedure [