Distributed query processing in the presence of blank nodes

Abstract

This paper demonstrates that the presence of blank nodes in RDF data represents a problem for distributed processing of SPARQL queries. It is shown that the usual decomposition strategies from the literature will leak information – even when information derives from a single source. It is argued that this leakage, and the proper reparational measures, need to be accounted for in a formal semantics. To this end a set semantics for SPARQL is generalized with a parameter representing execution contexts. This makes it possible to keep tabs on the naming of blank nodes across execution contexts, which in turn makes it possible to articulate a decomposition strategy that is provably sound and complete wrt. any selection of RDF sources even when blank nodes are allowed. Alas, this strategy is not computationally tractable. However, there are ways of utilizing knowledge about the sources, if one has it, that will help considerably.

Keywords

SPARQL federation distributed query processing logical foundation completeness decomposition scheme

1. Introduction

This paper is concerned with giving a general theoretical foundation for the semantics of distributed SPARQL processing. It was inspired in part by the observation that whilst a number of distributed SPARQL processors exist already, foundational work that allows one to study their relative behaviour in a principled manner is still in short supply.

In most ways, the present study can be regarded as a sequel to [35], in which the concept of a federation scheme was first introduced. Essentially, a federation scheme is a theoretical device that captures formally the conditions under which a particular federation strategy will yield sound and complete answer sets. Contrapositively, it can be regarded as a way of characterizing the behaviour of the federation strategy in question by making theoretically explicit when it will miss answers and why. While [35] gave several examples of sound and complete ways of decomposing and evaluating a query over a set of sources, these results were valid under the proviso that the contributing sources do not employ blank nodes for encoding information. The main contribution of the present paper is to remove this restriction thus giving, for the first time we believe, a fully general declarative semantics for distributed processing of SPARQL basic graph patterns.

There is a singular tension in the Resource Description Framework (RDF) between, on the one hand, the strictly local validity of blank nodes and, on the other, the global pretensions of the data model. RDF affords a knowledge representation language for making assertions that are meant to be valid in a global or Web-wide scope. Yet, it recognizes the existence of entities that cannot be referenced outside their source of origin, and that cannot be identified across query execution contexts.

The Semantic Web community is deeply ambiguous in its attitude towards blank nodes. The Linked Data community generally shuns them – in Bizer [18] they are discussed under the heading “RDF features best avoided in the Linked Data context”. On the other hand, asserting the existence of something that one is not willing to name is generally recognized as indispensable for design patterns that rely on expressing general logical concepts such as n-ary relations, lists, sets or classes. However one sees it, there is no getting around the well-documented prevalence of blank nodes on the Web [19] – a fact which is not likely to change anytime soon.

In rough outline, the problem with blank nodes is that if a federator is to combine information across SPARQL endpoints, then it will have to join suitably small fragments of information from different sources. This in turn involves evaluating suitably small subqueries to get at all the partial answers that are required for answering the global query in full. Alas, in the process patterns may happen to be broken up that match a partial answer in a single source where a blank node figures in join position. If so, then that partial answer cannot be put back together afterwards, because the blank nodes that were previously joined will no longer be identifiable as the same node. The situation poses somewhat of a dilemma, and resolving it requires rather profound, though not too complex, amendments to the semantics of evaluating SPARQL basic graph patterns.

Admittedly, the fragment of SPARQL that consists only of basic graph patterns is a fragment that ignores many interesting and useful features of SPARQL. Yet, it is a natural fragment to start with since it is simple and mathematically well-behaved. Granted, it is an interesting question how, say, the non-monotonic features of SPARQL such as negation would alter the picture. Nevertheless, this is a question that is considered out of scope for the purposes of the present paper, though one it is hoped it will be easier to explore in the future on the basis of this paper.

The layout and specific contributions of this paper are as follows: Section 2 identifies and describes the adverse effect of blank nodes on distributed query processing, whilst Section 3 surveys related work in the area. Section 4 provides the semantic prerequisites for working out a solution to the said dilemma. This consists mainly in generalizing the SPARQL 1.1 semantics by adding a formal parameter for execution contexts to the notion of an answer set. The concept of an execution context is left largely implicit in the SPARQL 1.1 specification. In the distributed setting, it is a condition sine qua non for an adequate semantics and therefore needs to be formalized. Section 5 flexes the new semantic machinery by providing an existence theorem showing that if an answer to a query exists in a set of contributing sources taken as a whole, then there is a way to retrieve it, even when allowing for blank nodes. Section 6 reviews the federation-schemes framework as developed in [35] as a prerequisite for the subsequent section. It does not contribute any new results per se, but merely adapts the relevant concepts and definitions to the generalized semantics developed in Section 4. Finally, Section 7 ties the threads together by abstracting from the existence theorem in Section 5 a federation scheme that gives sound and complete answer sets in the absence of any knowledge about the structure of the sources, blank nodes allowed. However this section also shows that there is a rather steep price to pay for ignorance when blank nodes are involved. More specifically, it is shown that distributed query answering in the presence of blank nodes when no knowledge is available is inherently hard. Different ways to mitigate the situation are sketched based on obtaining knowledge either by regimentation of the sources or by probing them, pointing to interesting lines of future research.

2. Problem description

It seems reasonable, by default at least, to require of a distributed query processor that it neither misses nor invents answers; all and only the answers that are warranted by the sum total of information contained in the contributing sources should, if there are no overriding reasons to the contrary, be returned.

To illustrate what is meant here by ‘the sum total of information’, consider the two RDF graphs in Figs 1 and 2 respectively, call them source A and B. As should be apparent, they encode information about trophies won by Roger Federer and Raphael Nadal respectively in Grand Slam tournaments.1

¹
It is a slightly modified version of an example from [19].

Now, according to source A the Wimbledon tournament is a Grand Slam tournament but the French Open is not. One may assume that this is an unintentional omission on behalf of the curator of the data set. The missing piece of information is provided by source B, however, so when the two sources are merged, as in Fig. 3, all tennis events become appropriately classified. Therefore, the query in Fig. 4 – which asks for the name of a player and the year in which he won a Grand Slam tournament – when evaluated against the merge of the sources A and B, returns the answer in Fig. 5.

Fig. 1.

RDF source A.

Fig. 2.

RDF source B.

This answer set strictly includes that which is obtained by evaluating the query in Fig. 4 against each source separately before taking the union of the result, viz. Fig. 6. In other words, the sum of the whole is bigger than the sum of the parts. Specifically, the total amount of information contained by the two sources combined, resides not only in what each of them can contribute separately, but in also in the combination or join of elements across sources.

Fig. 3.

The union of sources A and B modulo renaming of blank nodes.

Fig. 4.

Get Grand Slam triumphs.

Fig. 5.

Answer over the merge of A and B.

Fig. 6.

Union of answers over A and B.

A distributed query processor should, in the absence of a good reason for sacrificing completeness, query the whole. That is, by combining results from partial queries evaluated separately against source A and B, it should return the table in Fig. 5 as the answer to the query in Fig. 4.

Generalizing from the present example – keeping the restriction to basic graph patterns in mind – one thus arrives at the following intuitive criterion of adequacy for a distributed query processor: the same answer should be returned as that which would be obtained were the query to be evaluated over the merge of the contributing sources. This concept of adequacy will have to be made more precise later, for there is leeway for different interpretations of it due to the appeal to the ‘sameness’ of answer sets. For now, however, and in relation to the example at hand, the question becomes: how must the query in Fig. 4 be decomposed and processed (vagueness intended) in order to satisfy the adequacy criterion?

Given the obviousness of all that has been said so far, it is somewhat surprising that there is no simple answer to this question. This is due to the fact that source A and B – as recommended by the Semantic Web Best Practices and Deployment Working Group – use blank nodes for expressing three-place predicates, in this case the predicate “X wins Y in year Z”. Due to this, the information expressed by the graphs depends on joins on blank nodes. In the distributed case, such a join, if it is not handled with special care, will quickly become a drain through which information will leak. As we shall see, this has to do with anaphoric reference being lost whenever the same blank node is processed in two separate execution contexts.

It is interesting to register that none of the more straightforward and better known query-decomposition strategies from the literature will work for this example. Consider for instance the even decomposition, so called in [35] (cf. Section 6) as implemented in DARQ [29]. This is the decomposition that evaluates each triple pattern (from the global query, let’s call it) against every source that may contain an answer for it (meaning that the RDF property from the triple pattern in question occurs in that source). For instance, the even decomposition will evaluate both of the triple patterns ?x :event ?event and ?x :year ?year from the query in Fig. 4 separately against each of A and B. Collecting the solutions, say, from source A in separate tables, we have the answer sets in Figs 7 and 8.

Fig. 7.

Answers to ?x :event ?event over A.

Fig. 8.

Answers to ?x :year ?year over A.

Here, the identifiers for blank nodes have been given distinct subscripts c and d to signify that they are not to be treated as the same names. This behaviour is mandatory according to SPARQL 1.1 specification which requires every distinct query to be treated as a separate query execution context. More precisely, every query defines a distinct and sealed scope for blank node identifiers, which means that a blank node from one execution context cannot be referenced in another. From a logical point of view this is an entirely legitimate restriction. Blank nodes are similar to existential variables and existential variables are anaphors within the same quantificational context only. Nevertheless, it is detrimental for the even distribution, because join information is not preserved by the two tables. Therefore, the even distribution is not a decomposition strategy that can be relied on to remain faithful to the ‘sum total’ of information contained in the contributing sources.

The problem generalizes, for no other well-known decomposition strategy fares any better. Take the one implemented in FedX [34] for instance. The FedX decomposition is similar to DARQ except that it groups triple patterns that are satisfiable by a single source only – so called exclusive groups – into the same subquery. This strategy is studied under the name of the standard decomposition in [35].

Exclusive groups anchor the triples involved to the same execution context, so they may in fortuitous cases solve the problem. However, the example currently under consideration shows that this is not in general so. Indeed, in the cases where it is so, it comes down to luck, because exclusivity has nothing to do essentially with blank nodes. In particular, there are no exclusive groups in the query in Fig. 4 wrt. source A and B, so the even and standard decompositions are the same in this case.

As a final example, consider the decomposition strategy implemented in ADERIS [25], which is that of assigning to each selected source G the maximal subsets $P_{i}$ of the global query P such that the signature of $P_{i}$ is covered by G. That is, if all of the RDF properties that occur in $P_{i}$ also occur in G then $P_{i}$ is routed to G as a single conjunctive query pattern. The partial results obtained are then combined by taking their union. It is not difficult to see that this strategy falls short of our proposed criterion of adequacy. The running example constitutes a counterexample, for all of the RDF properties in the query occur in both of the sources A and B. Hence, on the ADERIS approach the whole query would be evaluated against each of these sources, and the final result would be the union of the respective answer sets. But, as we have seen, this produces the table in Fig. 6 which misses the cross-site join that relates Roger Federer to his 2009 win.

Taking stock, these examples can be taken to show the following: If answering a query involves joins on blank nodes, then the granularity of the decomposition of that query matters a great deal. If the query is split too finely, then answers from a single source may be lost due to the loss of join information linking the partial answers. If on the other hand the query is split too coarsely, then cross-site joins may be lost. From a semantical point of view, distributed query answering is essentially about balancing these two opposing forces.

The delicateness of this balancing act has not been fully appreciated yet it seems: while it is reasonable to expect a distributed query processor to do better than to just collect solutions to the global query from each of the sources, it may so happen that the very attempt to do so, i.e. the attempt to harvest information by utilizing cross-site joins, is the very thing that causes it to do worse, because if there are joins on blank nodes in a contributing source, then that source will leak solutions if the global query is decomposed too finely.

As for the question of whether there even is a decomposition that can be made to work, the answer is affirmative for the example at hand at least, viz. the decomposition below: $\begin{array}{l} P_{1} & : = {?athl :wins ?x., \\ ?x :event ?event., \\ ?x :year ?year.} \\ P_{2} & : = {?athl a :TennisPlayer.} \\ P_{3} & : = {?event a :GSTournament.} \end{array}$ The crucial thing about this decomposition is first, that it groups together those triple patterns that match a join on a blank node, thus ensuring that the join arguments are kept within one and the same execution context so as not to lose anaphoric reference ( $P_{1}$ ). Secondly, it is also of crucial importance that all other triples are shipped as singletons, or else cross-site joins would be lost ( $P_{2}$ and $P_{3}$ ). It is not difficult to show that the procedure that takes the union ${{⟦ P_{i} ⟧}_{A} \cup ⟦ P_{i} ⟧}_{B}$ for each $i \in [1, 3]$ before folding the results into a single answer set by joins, produces the outcome in Fig. 5. Yet, this solution is specific to the problem at hand and depends on detailed knowledge about the shape of the graphs being queried. For instance, one needs to know that the variable ?x will be mapped to a blank node – something that cannot, needless to say, be read off from the query alone.

We have the work cut out for us then: first it is necessary to show that irrespective of the shape of graphs, if a solution to a query is warranted by the merge of the contributing sources, then there is a decomposition from which that solution can be reconstructed. Secondly, it must be shown that it is possible to abstract from these particular solutions a general federation scheme that yields a correct and exhaustive answer set in the absence of any knowledge about the sources, even whilst allowing for joins on blank nodes. In order to do so, however, it will be necessary to generalize the SPARQL 1.1 semantics with an extra parameter representing execution contexts – a topic for the next section.

3. Related work

A tripartite classification of approaches to SPARQL federation is explicit in Görlitz and Staab [12] and implicit in Betz et al. [7] and Hose et al. [20]:

Lookup-based federation: Also known as federation-by-traversal, or follow-your-nose traversal [4], iteratively downloads and evaluates data based on links (usually as prescribed by the Linked Data principles [8]) from one dataset into another. The answer to a query is composed by cumulatively adding answers from incoming data during the traversal process. This approach is exemplified by e.g. [14–17] and [23].

Warehousing: Broadly understood, warehousing covers approaches that seek to collect or assemble all data of relevance ahead of query time into a repository that behaves as if it is a centralized single store. This area naturally shades off into cloud computing [32], distributed file systems, and big data technologies. Recent efforts in this direction focus on the use of cluster technology such as MapReduce and Hadoop e.g. [10,19,21,22,24] and [28], Spark e.g. [9] and GraphX e.g. [31].

Distributed query processing: Distributed query processing relies on analysing a query to identify a set of relevant RDF graphs – with or without the aid of statistics – to which subqueries can be assigned. Like federation-by-traversal and unlike warehousing, queries are evaluated remotely. Examples of this approach include [3,6,27,29] and [34].

If the issue were pressed, the present paper would be most naturally classified as belonging to the field of distributed query processing. However, it does not really advocate ‘an approach’ to SPARQL federation. Rather, it aims to articulate and develop a set of semantical primitives in terms of which any federation engine ought to be describable. To the authors’ knowledge it is the first foundational study of distributed query processing that allots to blank nodes a clearly described role in a strictly logico-mathematical theory.

It should be said that the tripartite classification mentioned above is very rough, and cuts across important and interesting distinctions in the literature. Conversely, there are subfields within federation that cut across it. It can plausibly be argued for instance that scalability and optimization are issues that are largely independent, or at least not tightly coupled with, any one particular approach. On the contrary, a lot of work seems to be going on here with more general significance.

To mention but a few, there is the area of adaptive query answering that explores how the evaluation of a query may be adjusted at run-time, e.g. by reordering joins [2] or by exploiting approximate membership functions reducing HTTP requests [36]. There is also a fair bit of activity in the field of caching, data replication and load balancing. For instance, [26] explores the use of replicated fragments of data graphs in order to mimimize the size of intermediate results, whereas [37,38] adresses client-server load balancing through the use of so called Triple Pattern Fragments (TPFs).

As regards, the relationship between the present theory and the SPARQL 1.1 federation extension, the two are essentially orthogonal to each other: the latter, by providing the SERVICE keyword for source selection, provides a way of evaluating different parts of a query against different endpoints, but it doesn’t tell you which parts. The present paper, in contrast, is concerned precisely with the question of which parts one can rely on to retain soundness and completeness. i.e. it is concerned with defining decompositions that are logically well-behaved.

4. Adding execution contexts to the SPARQL semantics

The formal developments that follow are based on the set version of the SPARQL 1.1 semantics as defined in [5] – or at any rate, as far as it goes. We say “as far as it goes”, because that semantics is designed for the case where a single query is evaluated against a single source in a single execution context. But what is distinctive about the distributed setting, is that the overall answer to the distributed query is assembled from partial answers to partial queries each one of which represents a distinct execution context. These contexts matter a great deal from a semantical point of view as they constitute disjoint name spaces for blank nodes, which in turn influences the semantics of joins.

Execution contexts are not formally defined in the SPARQL 1.1 semantics, which therefore lacks the expressive power to define distributed query processing. However, the following passage provides a fairly robust basis for a formal reconstruction: “Since SPARQL treats blank node identifiers in a results format document as scoped to the document, they cannot be understood as identifying nodes in the active graph of the dataset. If DS is the dataset of a query, pattern solutions are therefore understood to be not from the active graph of DS itself, but from an RDF graph, called the scoping graph, which is graph-equivalent to the active graph of DS but shares no blank nodes with DS or with [the query]” [13].

The scoping graph mentioned here is a purely theoretical construct – it is just another namespace for blank nodes. In other words, SPARQL distinguishes between the scopes of a query, the queried data and the result, stipulating that blank nodes cannot be shared between them. This has important formal ramifications that will be explored shortly, after the requisite semantic concepts have been introduced.

The following notational conventions will be adopt-ed from here on: curly braces are omitted from singletons in set-theoretic expressions as well as from arguments of functions if no confusion is likely to ensue, e.g. $P \cup t$ instead of $P \cup {t}$ and $f (t)$ instead of $f ({t})$ . Also, when f is a function and A a subset of f’s domain, then $f (A)$ will be used as a shorthand for the set of elements b such that $b = f (a)$ for some $a \in A$ . If f is a function, $dom (f)$ and $ran (f)$ are its domain and range respectively.

Turning now to RDF specifics, let I, B and L denote pairwise disjoint infinite sets of IRIs, blank nodes, and literals respectively. In conformity with the nomenclature of [5], $IL$ abbreviates $I \cup L$ and T abbreviates $I \cup B \cup L$ . These latter sets will be referred to collectively as RDF terms, and RDF terms will be denoted individually by $u_{i}$ , $v_{j}$ . Here, as everywhere else, indexes will be omitted when idle. An RDF triple is an element $(u_{1}, u_{2}, u_{3}) \in (I \cup B) \times I \times (I \cup B \cup L)$ . If it is mnemonically convenient, terms in triples may be denoted by their roles as subject, predicate and object of that triple; $(s, p, o)$ . If the elements of a triple is irrelevant to the discussion, an RDF triple will be denoted $a_{i}$ where the ‘a’ is meant to stand for ‘assertion’. An RDF graph is a finite set of RDF triples. RDF graphs are denoted G with or without subscripts. RDF graphs may also be referred to as RDF sources. These terms are intended to mean the same thing, but will tend to be used for different emphasis and in order to make the terminology more suggestive.

Turning now to SPARQL queries, let V be an infinite set of variables. Variables are denoted by lower case letters in the range of x to z with a question mark prepended. Variables may also be counted as terms, in which case they too are denoted $u_{i}$ .

Definition 4.1.
A basic graph pattern (BGP) is either
a singleton ${t}$ where t is a triple pattern in $(IL \cup V) \times (I \cup V) \times (IL \cup V)$ , or

a union $P_{i} \cup P_{j}$ of BGPs $P_{i}$ and $P_{j}$ .

Thus, $t_{i}$ denotes triple patterns and $P_{i}$ denotes BGPs. For any BGP P, $var (P)$ denotes the set of variables in P. In order to avoid tedious limiting cases in proofs, it will be assumed that the set of triple patterns is disjoint from the set of RDF triples, that is, a triple pattern is assumed to contain at least one variable. By Definition 4.1(1), it is also assumed not to contain blank nodes. These assumptions incur no loss of generality.

Following [5], SPARQL queries will be identified with basic graph patterns. In other words, the distinction between the syntax and the semantics of SPARQL queries will deliberately be blurred. Concretely, this means that queries will be treated as sets of triple patterns rather than as syntactic entities in and of themselves. This is mathematically convenient and simplifies formal developments without loss of precision. Abiteboul et al. [1] establishes precedent in this respect.

In the SPARQL 1.1 specification answers to simple conjunctive queries aka. basic graph patterns are formalized in terms of solution mappings, which are partial functions μ of type $V ⟶ T$ . The relevant definition, giving the answer ${⟦ P ⟧}_{G}$ to a basic graph pattern P evaluated over an RDF graph G, reads:
Definition 4.2.
Let G be an RDF graph, and P a BGP. Let $μ (t)$ denote the triple obtained by replacing the variables in t according to μ, and let $var (t)$ denote the set of variables occurring in t. Then
${⟦ P ⟧}_{G} =_{df} {μ | dom (μ) = var (t) and μ (t) \in G}$ , if P is a triple pattern t, or

${{{⟦ P ⟧}_{G} =_{df} ⟦ P_{i} ⟧}_{G} ⋈ ⟦ P_{j} ⟧}_{G}$ , if $P = P_{i} \cup P_{j}$ .

Here $μ (P)$ denotes the set of all $(μ (u_{1}), μ (u_{2}), μ (u_{3}))$ for $(u_{1}, u_{2}, u_{3}) \in P$ . Individual μ will be called solutions whereas sets ${⟦ P ⟧}_{G}$ will be called answer sets. The join ⋈ of answer sets is defined as the set of pairwise unions of compatible maps where $μ_{i}$ and $μ_{j}$ are compatible if $x \in dom (μ_{i}) \cap dom (μ_{j})$ implies $μ_{i} (x) = μ_{j} (x)$ .

This is the standard definition of answer sets as it looks in the set version of the SPARQL 1.1 semantics. Yet, keeping the SPARQL 1.1 specification’s notion of a scoping graph in mind, it is already not entirely accurate – not even for a single source and a single execution context. For if a solution $μ (t)$ to t over G happens to contain a blank node, it follows that $μ (t)$ is not strictly speaking an element in G. Rather, the relationship between $μ (t)$ is a weaker one: μ being a solution to t over G means that there is an $a \in G$ such that $μ (t)$ and a are the same up to renaming of blank nodes. This in turn is just to say that $μ (t)$ and a simply entail each other, where the following theorem from [19] may serve as the definition of simple entailment:
Theorem 4.1 (Simple entailment).

An RDF graph $G_{i}$ entails an RDF graph $G_{j}$ , written $G_{i} ⊨ G_{j}$ , iff there is an RDF homomorphism h from $G_{j}$ to $G_{i}$ .

The concept of an RDF homomorphism that figures in this definition will be defined shortly. Henceforth, whenever two answer sets are said to be the same, this is intended to mean that they simply entail each other, i.e. that they are simply equivalent, represented symbolically as .

The upshot of this is that even in the single-source case, SPARQL semantics can be seen to have an equivalential basis, and is thus not really expressible in terms of membership alone. This is not all bad news. On the contrary, it fits hand-in-glove with distributed query processing, for as soon as the equivalential basis of answer sets over a single source is made formally explicit it generalizes straightforwardly to answer sets obtained by combining solutions from different execution contexts.

The notational apparatus will have to be amended slightly. Starting with a countably infinite set of contexts $C$ (definition pending) what is required is a family of pairwise disjoint sets of blank nodes to match. It suffices to just stipulate that ${B_{c}}_{c \in C}$ is the family of sets $B_{c}$ obtained by making a copy of B in which each element is indexed by the context c. To lighten the notation the union of all these sets of blank nodes, one for each context, will henceforth be denoted $B$ . The set $ST$ of SPARQL terms may now be defined as $\begin{matrix} ST =_{df} IL \cup B \end{matrix}$ This is to be kept distinct from T, the set of RDF terms. The latter is the stuff that RDF graphs are made of, the former is the stuff that solutions to queries are made of. The same blank node is never contained in both.

Returning now to RDF homomorphisms:

Definition 4.3.
Given two RDF graphs $G_{i}$ and $G_{j}$ , an RDF homomorphism is a function $h : G_{i} ⟶ G_{j}$ such that all of the following hold:
$h (u) = u$ for $u \in IL$ ,

$h (u) \in T$ if $u \in B$ , and

$(h (u_{1}), h (u_{2}), h (u_{3})) \in G_{j}$ if $(u_{1}, u_{2}, u_{3}) \in G_{i}$ .

This definition differs from the standard only in that the range of functions has been extended with the new (countable) set of blank nodes. As for the concept of an execution context, viz. the following definition:
Definition 4.4 (Execution context).

An execution context is a bijection $c : T ⟶ ST$ which is such that

$u \in IL$ implies $c (u) = u$ ,

$u \in B$ implies $c (u) \in B_{c}$ .

The idea now, is to let the partial map μ, as defined in the standard semantics, figure merely as the mathematical relationship between a graph pattern and a graph that is to be portrayed by solutions proper. Stated differently, μ is no longer considered a solution per se, rather a solution $μ_{c}$ is a mapping μ modulo a context c that provides the solution with a unique set of names for its blank nodes:

Definition 4.5.
Given a $μ : V ⟶ T$ and a context c, $μ_{c} : V ⟶ ST$ is defined as follows:
$μ_{c} (u) = μ (u)$ whenever $μ (u) \in IL$ ,

$μ_{c} (u) = c (μ (u))$ otherwise.

Generalizing Definition 4.2 accordingly yields.
Definition 4.6 (Generalized evaluation).

Let $G$ denote a set of RDF sources, then:

${⟦ P ⟧_{G}^{c} =_{df} {μ_{c} | μ \in ⟦ P ⟧}_{G}}$ .

$⟦ P ⟧_{G}^{c} =_{df} ⟦ P_{i} ⟧_{G}^{c} ⋈ ⟦ P_{j} ⟧_{G}^{c}$ , if $P = P_{i} \cup P_{j}$ .

$⟦ P ⟧_{G}^{c} =_{df} ⟦ P ⟧_{⋃_{G_{i} \in G} G_{i}}^{c}$ .

The following pair of lemmas is unglamorous but important:

Lemma 4.2.
An execution context c is an RDF homomorphism from $μ (P)$ to $μ_{c} (P)$ .
Proof.
Suppose ${μ \in ⟦ P ⟧}_{G}$ , and $(μ (u_{1}), μ (u_{2}), μ (u_{3})) \in μ (P)$ for $(u_{1}, u_{2}, u_{3}) \in P$ , where $u_{1}$ , $u_{2}$ , $u_{3} \in IL \cup V$ . Then, by Definition 4.6(1) $μ_{c} \in ⟦ P ⟧_{G}^{c}$ i.e. $(μ_{c} (u_{1}), μ_{c} (u_{2}), μ_{c} (u_{3})) \in μ_{c} (P)$ . By the RDF semantics, $μ (u_{2}) \in I$ from which it follows that $μ (u_{2}) = μ_{c} (u_{2})$ by Definition 4.5(1), hence $μ_{c} (u_{2}) \in I$ . Now, assume wlog. that $μ (u_{1})$ , $μ (u_{3}) \in B$ , as the case for $μ (u_{1})$ , $μ (u_{3}) \in IL$ would proceed as for $u_{2}$ above.

By Definition 4.5(1) and (2), we then have $(c (μ (u_{1})), μ (u_{2}), c (μ (u_{3}))) \in μ_{c} (P)$ , and by Definition 4.4(1) we have $c (μ (u_{2})) = μ (u_{2})$ .

Therefore $(c (μ (u_{1})), c (μ (u_{2})), c (μ (u_{3}))) \in μ_{c} (P)$ and hence c satisfies Definition 4.3(3). That c also satisfies Definition 4.3(1) and (2) is immediate from Definition 4.4. □
Lemma 4.3.
The converse of a context c is an RDF homomorphism.
Proof.
By Lemma 4.2, c is a homomorphism which by Definition 4.4 is bijective. Hence $c^{- 1}$ is a graph homomorphism. To verify that it is in fact an RDF homomorphism it suffices to note that Definition 4.3(1) imposes the same restriction as Definition 4.4(1) and that Definition 4.4(2) is a stronger requirement than Definition 4.3(2). □

Taking stock so far, there is no longer such a thing as the set of answers to a BGP P over a graph G, strictly speaking. When blank nodes are involved there are infinitely many distinct such sets, one for each context c. These sets are all simply equivalent, though, which just means that they answer the query in essentially the same way:
Corollary 4.4.
If $var (P) \subseteq dom (μ)$ then $μ (P)$ , $μ_{c} (P)$ and $μ_{d} (P)$ are all simply equivalent irrespective of the choice of c and d.
Proof.
By Lemmas 4.2 and 4.3 c is an RDF homomorphism from $μ (P)$ to $μ_{c} (P)$ and $c^{- 1}$ is an RDF homomorphism in the converse direction. By Theorem 4.1 then . By similar reasoning , and by the property of euclideanness for equivalence relations $μ_{c} (P) ⊨ ⊨ μ_{d} (P)$ . □

Corollary 4.4 thus expresses formally what was hinted at in Section 2 when it was said that the ‘sameness’ of answer sets would have to be made precise.

Turning now to distributed query answering and its semantics, its formalization is a matter of generalizing the ⋈ relation to apply to answer sets from different sources and parametrized by different execution contexts: $\begin{matrix} ⟦ P_{i} ⟧_{G}^{c} ⋈ ⟦ P_{j} ⟧_{H}^{d} \end{matrix}$ Such expressions will henceforth be stipulated to denote the set of unions $μ_{c}^{'} \cup μ_{d}^{″}$ of pairs of compatible maps $μ_{c}^{'} \in ⟦ P_{i} ⟧_{G}^{c}$ and $μ_{d}^{″} \in ⟦ P_{j} ⟧_{H}^{d}$ . There are a few things to note:
Theorem 4.5.
There is in general no context e such that $⟦ P_{i} ⟧_{G}^{c} ⋈ ⟦ P_{j} ⟧_{H}^{d} = ⟦ P_{i} \cup P_{j} ⟧_{G \cup H}^{e}$ .
Proof.
It suffices to argue the case where $G = H$ . Suppose for reduction that there is such a context e for every $P : = P_{i} \cup P_{j}$ and every source G. Then it is possible to choose P, G, $μ_{c}^{'}$ and $μ_{d}^{″}$ in such a way that $μ_{e} = μ_{c}^{'} \cup μ_{d}^{″}$ , where $μ_{c}^{'} \in ⟦ P_{i} ⟧_{G}^{c}$ and $μ_{d}^{″} \in ⟦ P_{j} ⟧_{G}^{d}$ , although $ran (μ_{c}^{'}) \cap B_{c} \neq \emptyset$ and $ran (μ_{d}^{″}) \cap B_{d} \neq \emptyset$ . But then $ran (μ_{e}) \cap B_{c} \neq \emptyset$ and $ran (μ_{e}) \cap B_{d} \neq \emptyset$ , either of which contradicts clause (2) of the Definition 4.4 of contexts. □

What this means is that there is in general no algebra on contexts and sources that allows one to reduce $⟦ P_{1} ⟧_{G}^{c} ⋈ ⟦ P_{2} ⟧_{G}^{d}$ to a single execution context. In particular we do not have $⟦ P_{1} ⟧_{G}^{c} ⋈ ⟦ P_{2} ⟧_{G}^{d} = ⟦ P_{1} \cup P_{2} ⟧_{G}^{c \cup d}$ or anything of the sort. This is as it should be. Distributed queries do not run in a single execution context. Theorem 4.5 simply reflects this fact.

As a consequence of this, there are two different things that need to be recognized as solutions to a query: first, any solution to the query over a single source, and secondly, any solution obtained by joining partial answers from different sources or contexts. Call the latter intercontextual joins, and let them be denoted with ρ. Intercontextual joins generalize cross-site joins: whereas a cross-site join is an intercontextual join, the converse does not necessarily hold. The ρ notation will be used primarily as a convention for indicating in the relevant parts of a proof or line of reasoning that an appeal to a context is neither required nor apt. We have:
Theorem 4.6.
Let $G_{m}$ and $G_{n}$ be two RDF graphs that are standardized apart. If $ρ \in ⟦ P_{i} ⟧_{G_{m}}^{c} ⋈ ⟦ P_{j} ⟧_{G_{n}}^{d}$ then there is a context e such that $μ_{e} \in ⟦ P_{i} \cup P_{j} ⟧_{G_{m} \cup G_{n}}^{e}$ and .
Proof.
By Definition 4.6(2) it suffices to show the property for a $μ_{e}$ in $⟦ P_{i} ⟧_{G_{m} \cup G_{n}}^{e} ⋈ ⟦ P_{j} ⟧_{G_{m} \cup G_{n}}^{e}$ . So suppose $ρ \in ⟦ P_{i} ⟧_{G_{m}}^{c} ⋈ ⟦ P_{j} ⟧_{G_{n}}^{d}$ . Then $ρ \in ⟦ P_{i} ⟧_{G_{m} \cup G_{n}}^{c} ⋈ ⟦ P_{j} ⟧_{G_{m} \cup G_{n}}^{d}$ by dataset monotony, whence $ρ = μ_{c}^{'} \cup μ_{d}^{″}$ for $μ_{c}^{'}$ in the first and $μ_{d}^{″}$ in the second of the join arguments. By Corollary 4.4 for an arbitrarily chosen e, and for the same e. From the former it follows by Theorem 4.1 that there is a pair $(h_{1}, g_{1})$ of RDF homomorphisms such that $h_{1}$ maps $μ_{c}^{'} (P_{i})$ into $μ_{e}^{'} (P_{i})$ and $g_{1}$ maps $μ_{e}^{'} (P_{i})$ back into $μ_{c}^{'} (P_{i})$ . From the latter it follows that there is a pair $(h_{2}, g_{2})$ linking $μ_{d}^{″} (P_{j})$ and $μ_{e}^{″} (P_{j})$ in the same way. The proof now proceeds from this to show that $μ_{e}$ defined as $μ_{e}^{'} \cup μ_{e}^{″}$ is a solution to $P_{i} \cup P_{j}$ : since $ρ = μ_{c}^{'} \cup μ_{d}^{″}$ entails $ρ (P_{i} \cup P_{j}) = μ_{c}^{'} (P_{i}) \cup μ_{d}^{″} (P_{j})$ , it suffices to show that A) $h_{1} \cup h_{2}$ is an RDF homomorphism from $μ_{c}^{'} (P_{i}) \cup μ_{d}^{″} (P_{j})$ to $μ_{e}^{'} (P_{i}) \cup μ_{e}^{″} (P_{j})$ and that B) $g_{1} \cup g_{2}$ is a homomorphism in the converse direction.

For A) it suffices to show that $h_{1} \cup h_{2}$ is well-defined, i.e. that $h_{1}$ and $h_{2}$ are compatible. So, suppose for reduction that there is a term $u \in dom (h_{1}) \cap dom (h_{2})$ such that $h_{1} (u) \neq h_{2} (u)$ . By the definition of an RDF homomorphism u must be a blank node. However, the contexts c and d, by Definition 4.4, have disjoint ranges when restricted to blank nodes, so $u \notin dom (h_{1}) \cap dom (h_{2})$ contrary to assumption.

For B) the reasoning is entirely similar to A) so suppose for reduction that there is a term $u \in dom (g_{1}) \cap dom (g_{2})$ such that $g_{1} (u) \neq g_{2} (u)$ . Then again u must be a blank node, by the definition of an RDF homomorphism. However $G_{m}$ and $G_{n}$ have been assumed to be standardized apart so $u \notin dom (g_{1}) \cap dom (g_{2})$ contrary to assumption. □

As this argument can obviously be extended to all finite unions of BGPs by a straightforward induction, it is in effect akin to a soundness result: as long as execution contexts do not share blank node identifiers with one another or with RDF graphs, and as long as the scope of RDF graphs are treated as mutually exclusive, distributed query processing, understood as assembling intercontextual joins across sources and contexts, never produces solutions that are not warranted by the union of those sources.
5. There is always a solution

To recapitulate briefly, the point of introducing an explicit parameter for execution contexts is to be able to reason about the total information content held by a set of answers each of which was generated by a different query over a distinct source – the total information content being given by the join over all these sets. Now, as each query will set up a separate scope for blank node identifiers that is disjoint from all others, answer sets cannot in the distributed case be joined freely. In particular, any join on blank nodes, if it spans two or more execution contexts, must be deemed a false positive. Conversely, any join on blank nodes that refers to a single context is ok. In other words, execution contexts is essentially a way to keep tabs on legitimate and illegitimate joins.

The present section is concerned with the first of the tasks that were defined towards the end of Section 2 which, having introduced execution contexts into the SPARQL semantics, it is now possible to address: the aim is to show that irrespective of the shape of graphs, if a solution to a query is warranted by the merge of the contributing sources, then there is a decomposition from which that solution can be reconstructed.

The investigative strategy that is adopted here is to reverse-engineer the problem by showing that every solution over the merge of the contributing sources induces a decomposition that fits the bill. More specifically, the idea is to let those parts of the given solution that have joins on blank nodes dictate how the corresponding query pattern is to be decomposed; for if a graph pattern is connected by blank nodes, it must derive from a single source, so the subquery that matches it must be grouped and evaluated in a single execution context.

Thus, we shall be interested in those subpatterns $P_{i}$ of a global query P that select subgraphs of the source being queried that are connected by blank nodes in the following sense:

Definition 5.1 (b-connectedness).

Let G and ${a}$ be RDF graphs, then

${a}$ is b-connected,

$G \cup {a}$ is b-connected if G is b-connected and G and a share a blank node.

It is worth noting that, in the limiting case, the definition makes every triple pattern that, parameterized by $μ_{g}$ , does not select an assertion with blank nodes in it b-connected.

The definition of a b-connected set (wrt. $μ_{g}$ ) induces a corresponding notion of a b-component (wrt. $μ_{g}$ ):

Definition 5.2 (b-component).

Let $μ_{g}$ be any solution in $⟦ P ⟧_{G}^{g}$ , where $G$ is assumed to be standardized apart, and let $P_{i} \subseteq P$ . Then $P_{i}$ is a b-component of P iff $μ_{g} (P_{i})$ is a maximal b-connected subset of $μ_{g} (P)$ .

Note that b-connected sets are RDF graphs, whereas b-components are SPARQL query patterns. Consider the following example:

Example 5.1.
Consider the merge of the RDF graphs A and B in Fig. 3 and the query in Fig. 4. Let $μ_{g}$ be the solution that assigns $\begin{array}{l} ?athl \mapsto :Federer \\ ?x \mapsto_: b_{g} \\ ?event \mapsto :FrenchOpen \\ ?year \mapsto “2009” \end{array}$ Then the b-components of the query, relative to $μ_{g}$ , are given by the decomposition in Section 2, namely $\begin{array}{l} P_{1} & : = {?athl :wins ?x., \\ ?x :event ?event., \\ ?x :year ?year} \\ P_{2} & : = {?athl a :TennisPlayer.} \\ P_{3} & : = {?event a :GSTournament.} \end{array}$

Now, Example 5.1 seems to indicate otherwise, but it is a fact of some importance that $μ_{g} (P)$ being a b-component does not entail that P is connected. Consider the following example:
Example 5.2.
Put $G : = {(b, p_{1}, o_{1}), (b, p_{2}, o_{2})}$ where b is assumed to be a blank node. Let $P : = {(? x, p_{1}, o_{1}), (? y, p_{2}, o_{2})}$ . Then any $μ_{g} \in ⟦ P ⟧_{G}^{g}$ maps both $? x$ and $? y$ to b. Since G is connected, and maximally so, $μ_{g} (P)$ is consequently a b-component. Yet, P itself is not connected.

The significance of this is that one cannot limit ones’ view to connected subqueries when searching for a complete federation scheme. There will be more to say about this in the next section.

For stocktaking and for the sake of contrast, it might be instructive to review a couple of cases that are excluded by Definitions 5.1 and 5.2: First of all, and rather obviously, a maximal b-connected set is not the same as a set which is maximally such that each pair of triples is connected by a blank node. Consider Fig. 9, where for simplicity we let the properties $p_{1}, \dots, p_{n}$ name the triples they belong to. The subgraphs that are pairwise b-connected, and maximally so, are $G_{i} = {p_{1}, p_{2}, p_{3}}$ and $G_{j} = {p_{2}, p_{4}, p_{5}}$ . The triples denoted by $p_{3}$ and $p_{5}$ do not share blank nodes and therefore do not belong to the same pairwise b-connected set, i.e. they constitute a cutoff point for the purposes of this example. In contrast, the only maximal b-connected subgraph of Fig. 9 according to Definition 5.1 is $G_{i} \cup G_{j}$ , that is, the whole graph.

Considering how blank nodes are renamed in each execution context, one can appreciate why it is $G_{i} \cup G_{j}$ that must be deemed to reflect the correct concept of b-connectedness: Since $G_{i}$ and $G_{j}$ themselves share blank nodes, it follows that if they did induce separate b-components with variables in the positions occupied by the blank nodes, then the blank node that is shared between them would be renamed in two separate execution contexts whence that join would be missed.

Elaborating on this example a bit, the lopsidedness of the concept of pairwise b-connectedness could be counteracted by stipulating instead that a b-connected set is one in which all pair of triples are connected by an undirected path where all interior nodes on the path are blank nodes. It is easily verified that the only subgraph of Fig. 9 which is maximal in this respect is the entire graph, as this example demands.

However, it is not too difficult to rig up another graph which shows that this time we have overshot our target insofar as the latter concept is not discriminating enough. Consider the graph Fig. 10. There is a path of the kind described between every pair of triples, so the graph itself is the only connected component according to this latter concept of connectedness. However, $p_{6}$ and $p_{7}$ do not have blank nodes at all, so any query that does not treat the corresponding triple patterns as separate subqueries will risk losing cross-site joins. In other words, the maximal b -connected components of the graph in Fig. 10 should be deemed to be $G_{i} = {p_{1}, p_{2}, p_{3}, p_{4}, p_{5}}$ , $G_{j} = {p_{6}}$ and $G_{k} = {p_{7}}$ which is precisely what Definition 5.1 yields.

Fig. 9.
Counterexample 1.

Fig. 10.
Counterexample 2.

It will be convenient to have a notation that assembles all the b -components that a particular solution induces:
Definition 5.3.
The set of b-components of P relative to $μ_{g}$ is denoted by $f (μ_{g}, P)$ .

The next two lemmas record some important properties about f as so defined.
Lemma 5.1.
$f (μ_{g}, P)$ partitions P.
Proof.
According to Definition 5.1 the empty set is not b-connected, hence any $P_{i} \in f (μ_{g}, P)$ is non-empty. For exhaustiveness we need to show that $\begin{matrix} P = ⋃_{P_{i} \in f (μ_{g}, P)} P_{i} \end{matrix}$

The right-to-left inclusion is trivial. For the converse suppose $t \in P$ . If t is a b-component then ${t} \in f (μ_{g}, P)$ , so there is nothing to prove. If not, then, since $μ_{g} (t)$ is vacuously b-connected then t is not maximal in this respect. In other words, ${t}$ can be extended to a set $P_{i} \subseteq P$ such that $μ_{g} (P_{i})$ is b-connected and $P_{i}$ is maximal among the subsets of P for which this holds. In other words, $P_{i} \in f (μ_{g}, P)$ which completes the verification of exhaustiveness.

It remains to show that the elements of $f (μ_{g}, P)$ are pairwise disjoint. So, let $P_{i}$ , $P_{j}$ be an arbitrarily chosen pair of elements of $f (μ_{g}, P)$ and assume for the sake of contradiction that $t \in P_{i} \cap P_{j}$ for $P_{i} \neq P_{j}$ . There are two cases to consider: Case 1.
$μ_{g} (t)$ contains no blank nodes: Then, $μ_{g} (t)$ is b-connected according to Definition 5.1, and there is clearly no $P_{i} \subseteq P$ such that ${t} \subset P_{i}$ and $μ_{g} (P_{i})$ is b-connected. Hence, by Definition 5.2 ${t}$ is itself a b-component, from which it follows that $P_{i} = {t} = P_{j}$ and therefore $P_{i} = P_{j}$ contrary to assumption.
Case 2.
$μ_{g} (t)$ contains a blank node: There are two subcases: either $P_{i} \subset P_{j}$ , or $P_{i} ⊈ P_{j}$ .
Case 2.1.
$P_{i} \subset P_{j}$ : Then $μ_{g} (P_{i})$ is not maximally b-connected as per Definition 5.2, hence $P_{i}$ is not a b-component (contradiction).
Case 2.2.
$P_{i} ⊈ P_{j}$ : Since they are both b-components, then by Definition 5.2, $μ_{g} (P_{i})$ and $μ_{g} (P_{j})$ are each b-connected. However, since they overlap on t, this means that $P_{i} \cup P_{j}$ is also a b-component contradicting the maximality of $P_{i}$ and $P_{j}$ . □

Lemma 5.2.
f is a function.
Proof.
Let $x : = (μ_{g}, P)$ and suppose $(x, Y_{i})$ , $(x, Y_{j}) \in f$ , we need to show that $Y_{i} = Y_{j}$ . Suppose for reduction that $Y_{i} \neq Y_{j}$ , say wlog. $P_{k} \in Y_{i} ∖ Y_{j}$ . Since $P_{k} \in Y_{i}$ it is a b-component of P relative to $μ_{g}$ . By Lemma 5.1, $Y_{j}$ is a partition of P, so $P_{k} \subseteq ⋃ Y_{j}$ . However, $P_{k} \notin Y_{j}$ , thus there are two cases to consider: Case 1.
$P_{k}$ is a proper subset of a cell in $Y_{j}$ , that is, $P_{k} \subset P_{l} \in Y_{j}$ for some $P_{l}$ . Then contrary to assumption $P_{k}$ is not a b-component.
Case 2.
$P_{k}$ is split among cells in $Y_{j}$ , that is, there exists a $P_{l} \in Y_{j}$ s.t. $P_{k} ⊈ P_{l} \in Y_{j}$ but $P_{k} \cap P_{l} \neq \emptyset$ . Since $P_{k}$ and $P_{l}$ are b-components, $μ_{g} (P_{k})$ and $μ_{g} (P_{l})$ each satisfy Definition 5.1, hence are b-connected. But since $P_{k} \cap P_{l} \neq \emptyset$ this is true also of $μ_{g} (P_{k} \cup P_{l})$ contradicting the maximality of $P_{k}$ and $P_{l}$ in this respect. □

The combined significance of these two lemmas may be explained as follows: Lemma 5.2 fixes a single set $f (μ_{g}, P)$ of subpatterns of P, which according to Lemma 5.1 mutually exhaust P. Taken together, therefore, they show that talk of $f (μ_{g}, P)$ as one decomposition of P is legitimate. This decomposition has special properties:
Lemma 5.3.
Let P be a query, $G = ⋃_{i \in I} G_{i}$ a set of sources that are standardized apart, and $μ_{g} \in ⟦ P ⟧_{G}^{g}$ . Then, for any $P_{i} \in f (μ_{g}, P)$ there exists a source $G_{k} \in G$ such that $μ_{c}^{'} \in ⟦ P_{i} ⟧_{G_{k}}^{c}$ and for any execution context c.
Proof.
Put $μ^{'} : = μ_{| vars (P_{i})}$ . Then ${μ^{'} \in ⟦ P_{i} ⟧}_{G}$ . By Corollary 4.4 it suffices to show that ${μ^{'} \in ⟦ P_{i} ⟧}_{G_{k}}$ for some $G_{k} \in G$ . The proof subdivides into two cases: Case 1.
$μ^{'} (P_{i})$ contains blank nodes: Suppose for reduction that there is no single $G_{k} \in G$ with ${μ^{'} \in ⟦ P_{i} ⟧}_{G_{k}}$ . Then ${μ^{'} \in ⟦ P_{i} ⟧}_{G}$ means that $μ^{'} (P_{i})$ must span at least two sources $G_{k}, G_{j} \in G$ . Now, $μ^{'} (P_{i})$ is b-connected, since $P_{i} \in f (μ_{g}, P)$ , so it is possible to choose triple patterns $t_{m}, t_{n} \in P_{i}$ such that $a_{m} : = μ^{'} (t_{m}) \in G_{j}$ , $a_{n} : = μ^{'} (t_{n}) \in G_{k}$ and such that ${a_{m}, a_{n}}$ is b-connected. By Definition 5.1 $a_{m}$ and $a_{n}$ share a blank node. However, this contradicts the assumption that $G_{k}$ and $G_{j}$ are standardized apart.
Case 2.
$μ_{g} (P_{i})$ does not contain a blank node: Then $P_{i}$ is a singleton ${t}$ , so the desired result follows immediately. □

In words, Lemma 5.3 demonstrates that every element $P_{i}$ of $f (μ_{g}, P)$ is such that there exists a single source in the set of sources in question capable of answering $P_{i}$ in a manner equivalent to $μ_{g}$ . Needless to say, therein lies the essence of federation, or more accurately, one half of it. The other “half” is given by Lemma 5.4:
Lemma 5.4.
Suppose $P_{m}, P_{n} \in f (μ_{g}, P)$ , and . Then .
Proof.
Suppose the conditions of the theorem hold. Since $μ_{g} (P_{m} \cup P_{n}) = μ_{g} (P_{m}) \cup μ_{g} (P_{n})$ it suffices to show . By Theorem 4.1, this in turn reduces to demonstrating the existence of an RDF homomorphism from left to right and one from right to left. By the supposition of the theorem the property holds for each of the component patterns. That is, there is a pair of RDF homomorphisms $(h_{1}, g_{1})$ of $μ_{c}^{'} (P_{m})$ to $μ_{g} (P_{m})$ and back, and a pair $(h_{2}, g_{2})$ of $μ_{d}^{″} (P_{n})$ to $μ_{g} (P_{n})$ and back. We show that $(h_{1} \cup h_{2}, g_{1} \cup g_{2})$ is a pair of RDF homomorphisms of $μ_{c}^{'} (P_{m}) \cup μ_{d}^{″} (P_{n})$ to $μ_{g} (P_{m}) \cup μ_{g} (P_{n})$ and back.

For $h_{1} \cup h_{2}$ , it is necessary to verify first of all that it is well-defined, i.e. that for any $u, v \in ST$ if $u = v$ then $h_{1} (u) = h_{2} (v)$ . The verification subdivides into two cases depending on the sets to which u and v belong. To ease the notation put $h^{+} : = h_{1} \cup h_{2}$ . Case 1.
$u, v \in B$ . If $u, v \in μ_{c}^{'} (P_{m})$ then $h^{+} (u) = h_{1} (u) = h_{1} (v) = h^{+} (v)$ . Similarly, if $u, v \in μ_{d}^{″} (P_{n})$ then $h^{+} (u) = h_{2} (u) = h_{2} (v) = h^{+} (v)$ . Suppose therefore wlog. that $u \in μ_{c}^{'} (P_{m})$ and $v \in μ_{d}^{″} (P_{n})$ . Then it follows by Definition 4.4(2) that $u \neq v$ contrary to assumption.
Case 2.
$u, v \in IL$ : Then since $h_{1}$ and $h_{2}$ are RDF homomorphisms, they are the identity on u and v, whence $\begin{array}{l} h^{+} (u) & = (h_{1} \cup h_{2}) (u) \\ = h_{1} (u) \cup h_{2} (u) \\ = u \\ = v \\ = h_{1} (v) \cup h_{2} (v) \\ = (h_{1} \cup h_{2}) (v) \\ = h^{+} (v) \end{array}$

It remains to verify that $h^{+}$ is an RDF homomorphism, so suppose $(s, p, o) \in μ_{c}^{'} (P_{m}) \cup μ_{d}^{″} (P_{n})$ . Then either $(s, p, o) \in μ_{c}^{'} (P_{m})$ or $(s, p, o) \in μ_{d}^{″} (P_{n})$ . Hence, either $h^{+} ((s, p, o)) = h_{1} ((s, p, o))$ or either $h^{+} ((s, p, o)) = h_{2} ((s, p, o))$ . In both cases $h^{+}$ is an RDF homomorphism, since both of $h_{1}$ and $h_{2}$ are. This completes the case for $h_{1} \cup h_{2}$ .

For $g_{1} \cup g_{2}$ , put $g^{+} : = g_{1} \cup g_{2}$ . To verify that $g^{+}$ is well-defined it suffices to check the case where $u, v \in B$ , the other one being similar to that for $h^{+}$ .

Suppose that either $u, v \in μ_{g} (P_{m})$ or $u, v \in μ_{g} (P_{n})$ holds. In the former case $g^{+} = g_{1}$ and in the latter $g^{+} = g_{2}$ . The desired result follows immediately from either by the functionality of $g_{1}$ and $g_{2}$ . It suffices, therefore, to confirm that $μ_{g} (P_{m})$ and $μ_{g} (P_{n})$ do not share blank nodes.

Suppose for contradiction and without loss of generality that $(b_{g}, p_{i}, o_{i}) \in μ_{g} (P_{m})$ and $(b_{g}, p_{j}, o_{j}) \in μ_{g} (P_{n})$ . Then $μ_{g} (P_{m}) \cup (b_{g}, p_{j}, o_{j})$ is b-connected as per Definition 5.1. Choose $t \in P_{n}$ such that $(b_{g}, p_{j}, o_{j}) = μ_{g} (t)$ . Then $μ_{g} (P_{m} \cup t) = μ_{g} (P_{m}) \cup (b_{g}, p_{j}, o_{j})$ . Since $f (μ_{g}, P)$ partitions P and $t \in P_{n}$ it follows that $t \notin P_{m}$ . Therefore $P_{m} \subset P_{m} \cup t$ so $P_{m}$ is not maximal in the sense of Definition 5.2. This contradicts $P_{m} \in f (μ_{g}, P)$ and completes the verification that $g^{+}$ is well-defined.

The verification that $g^{+}$ is an RDF homomorphism is exactly like that for $h^{+}$ , so the proof is complete. □

It may be worthwhile to pause to register what it is that makes this proof work: it is essentially a question of building larger RDF homomorphisms from smaller ones. This requires certain simple conditions to be met, most importantly that the union of functions be a function. Since the smaller functions in question are RDF homomorphisms, and RDF homomorphisms by definition map IRIs and literals to themselves, the only way this could go wrong is if the mapped element were a blank node. However, this cannot happen for the left to right direction, since execution contexts have disjoint ranges, and it cannot happen for the right to left direction since the solutions in question do not share blank nodes. Thus the theorem flows from two things: the relativization of answer sets to execution contexts and the splitting of queries into b-components.

It is now possible to prove the converse of Theorem 4.6 and the main result of this section:
Corollary 5.5.
Let $G : = ⋃_{i \in I} G_{i}$ be a set of sources, standardized apart, and let $μ_{g} \in ⟦ P ⟧_{G}^{g}$ . Then there is a partition $P_{1}, \dots, P_{n}$ of P such that, $ρ \in ⟦ P_{1} ⟧_{G_{1}}^{c_{1}} ⋈ \dots ⋈ ⟦ P_{n} ⟧_{G_{n}}^{c_{n}}$ for arbitrarily chosen $c_{1}, \dots, c_{n}$ and .
Proof.
Suppose the conditions of the corollary hold. Put $P_{1}, \dots, P_{n} = f (μ_{g}, P)$ . By Lemma 5.1 we have $P = P_{1} \cup \dots \cup P_{n}$ . Lemma 5.3 entails that for every $P_{k}$ there exists a source, say $G_{k}$ , a context, say $c_{k}$ , and a solution mapping, say $μ^{k}$ , such that $μ_{c_{k}}^{k} \in ⟦ P_{k} ⟧_{G_{k}}^{c_{k}}$ and . By extension of Lemma 5.4 to finite unions it follows that . Therefore, selecting $ρ : = μ_{c_{1}}^{1} ⋈, \dots, ⋈ μ_{c_{n}}^{n}$ proves the corollary. □

Whereas Theorem 4.6 says that cross-site joins can never be incorrect, provided that tabs are kept on execution contexts, Corollary 5.5 states that every solution to a query P returned by the merge of the contributing sources is contained in the join of the separate evaluation of the cells of some decomposition of P. Thus there is always a solution distributed in the contributing sources if there is a solution in their union modulo renaming of blank nodes – i.e. in their merge.

What Corollary 5.5 does not say, is how to obtain this decomposition when we do not know the structure of the sources. It was only possible to prove that a decomposition exists by assuming prior knowledge of a solution that could be used to partition the query. However, different solutions may require different decompositions. Yet, all solution cannot be assumed to be available if federation is to produce information one does not already possess. It remains, therefore, to abstract from Theorems 4.6 and 5.5 a general federation scheme that will deliver all solutions, and only solutions, over any set of contributing sources in the absence of any knowledge about them. For this, we shall need the concept of a federation scheme.
6. Federation schemes

The concept of a federation scheme was first introduced in [35] as a mathematical abstraction for reasoning about the distributed query answering process. It is meant to highlight the two complementary aspects of this process, which may be taken to consists respectively in decomposing a query over a set of sources and in assembling an answer to it from the partial answers returned by each contributing source. A federation scheme is thus a pair $(E, δ)$ of a decomposition function δ and an evaluation rule $E$ . Intuitively a decomposition function is responsible for assigning subqueries to contributing sources, whereas an evaluation rule is responsible for applying joins and unions (or in general any operation on answer-sets) in the right measure and order.

The soundness and completeness of a federation scheme is a relationship that holds wrt. a set of sets of contributing sources – or, in a more suggestive terminology, a set of selections of contributing sources: the federation scheme specifies how a graph pattern is to be distributed and evaluated over a set/selection of sources. Conversely the set of selections defines the permissible ways of choosing sources over which to distribute the decomposed query, where permissible means that soundness and completeness of query answering is preserved. Stated differently one might say that the set of sources specify in semantic terms the assumptions about the structure of the data that is built into the federation scheme.

The present section recalls the essentials of this formal framework, and generalizes it to the new equivalence-based semantics for distributed queries as set out in the previous section.

The minimal amount of knowledge one needs about a set of sources in order to distribute a query over them, is their signatures. Here a signature is understood essentially as the set of concrete predicates of an RDF graph or of a SPARQL pattern. The following definition covers both cases:

Definition 6.1.
Let S be a BGP or a set of RDF triples. The signature of S written $sig (S)$ is defined as $\begin{matrix} sig (S) =_{df} S^{2} \cap I \end{matrix}$ where $S^{2}$ denotes the projection of S onto its second coordinates.

Note that variables and blank nodes do not add to the signature of a graph pattern, and that blank nodes do not add to the signature of an RDF graph. Using signatures to route subqueries is a common stratagem in the literature (cf. [11] and [34]).
Definition 6.2.
If P is non-empty, then $\begin{matrix} Σ_{G} (P) =_{df} {G \in G : sig (P) \subseteq sig (G)} \end{matrix}$ Otherwise $Σ_{G} (P) =_{df} \emptyset$ .

It is a simple consequence of Definitions 6.1 and 6.2 that if $a^{2} \in V$ for some triple pattern a, that is, if a has a variable in predicate position, then $Σ_{G} (a) = G$ for any $G$ . A consequence of this is that a triple pattern that has a blank node or variable in predicate position will be routed to all sources in a selection.
Definition 6.3 (Decomposition function).

A decomposition function is a binary function δ that takes a set of RDF graphs $G$ and a BGP P and returns a set of pairs $(P_{i}, G_{j})$ such that $P_{i} \neq \emptyset$ and such that all of the following hold:

$G_{j} \subseteq Σ_{G} (P_{i})$ ,

if $(P_{i}, G_{i}), (P_{j}, G_{j}) \in δ (G, P)$ and $P_{i} = P_{j}$ then $G_{i} = G_{j}$ ,

$⋃_{(P_{i}, G_{j}) \in δ (G, P)} P_{i} = P$ .

Note that this definition does not necessarily partition P, it all depends on the signature of the sources. Clause (1) prevents a decomposition function from behaving erratically when it comes to assigning subqueries to sources. That is, a BGP is only assigned to sources that can potentially answer it. Clause (2) ensures that the value of a decomposition function on any selection of sources $G$ and any BGP P is itself a function, that is, that every subquery of P is assigned to exactly one subset of $G$ . Finally, clause (3) expresses a necessary condition for soundness: δ distributes P over $G$ only if P is decomposed into subqueries that jointly exhaust P. Note that δ as so defined is a partial function, that is, (1) and (3) can not be satisfied for arbitrary choices of $G$ and P, reflecting the fact that the accumulated signature of the sources may not cover the signature of the global query. If it does then δ will henceforth be said to be defined at $G$ and P.

6.1. Examples of decomposition functions

Section 2 mentioned the notion of an exclusive group of a query P relative to a selection of sources $G$ . This concept can be defined as:

Definition 6.4.
The subpattern of BGP P that is exclusive to an RDF graph G, relative to a set of RDF graphs $G$ , is the set: $\begin{matrix} E_{G} (P) =_{df} {t \in P : Σ_{G} (t) = {G}} \end{matrix}$ A triple pattern that is not an element of an exclusive group is called a non-exclusive triple pattern relative to the same selection of graphs.
In this form, Definition 6.4 goes back to [34].

The following theorem, the proof of which can be found in [35], gives examples of decomposition functions:
Theorem 6.1.
Let $G$ be any set of RDF graphs and P any BGP. Stipulate that $(P_{i}, G_{i}) \in δ (G, P)$ iff $G_{i} = Σ_{G} (P_{i})$ and one of the following conditions hold:
Even decomposition: $P_{i}$ is a singleton $t \in P$ .

Standard decomposition: either

$P_{i}$ is a non-exclusive singleton $t \in P$ , or

$P_{i} = E_{G} (P)$ for some $G \in G$ .

Prudent decomposition: either

$P_{i}$ is a non-exclusive singleton $t \in P$ , or

$P_{i}$ is a maximal connected subset of $E_{G} (P)$ for some $G \in G$ .

Then δ is a decomposition function in the sense of Definition 6.3 .

The effect of the second clause under the prudent decomposition is to avoid useless cartesian products in cells of the decomposition, something that is not excluded by the standard decomposition. The reader may wish to consult [35] for more detail.

Listing 1.
Query LS5 from FedBench.
Example 6.1.
Consider the query in Listing 1. This is query LS5 from the FedBench suite [33] which asks for all drugs from Drugbank, together with the URL of the corresponding page stored in KEGG and the URL to the image derived from ChEBI.

The signature of the query divides among the FedBench datasets as specified in Table 1. Presupposing this division, Table 2 gives the even, standard and prudent decompositions respectively. Blocks in a column correspond to subqueries and are labelled with the datasets to which that subquery is assigned. For instance, the standard decomposition assigns the subquery consisting of line 2 and 3 to KEGG, since 2 and 3 form an exclusive group for it. The non-exclusive triple pattern in line 4, in contrast, is assigned to both KEGG and ChEBI.

Table 1
Decomposition of the signature of query LS5

Signature element/property Dataset

rdf:type All

drugbank:keggCompundId Drugbank

drugbank:genericName Drugbank

bio2rdf:url KEGG, ChEBI

purl:title KEGG, ChEBI

bio2rdf:image ChEBI

Table 2
Decomposition of LS5 over KEGG, ChEBI and Drugbank

Nr. Triple pattern Even Standard Prudent

1 ?drug rdf:type drugbank:drugs All All All

2 ?drug drugbank:keggCompoundId ?keggDrug Drugbank Drugbank Drugbank

3 ?drug drugbank:genericName ?drugBankName Drugbank

4 ?keggDrug bio2rdf:url ?keggUrl KEGG, ChEBI KEGG, ChEBI KEGG, ChEBI

5 ?chebiDrug purl:title ?drugBankName KEGG, ChEBI KEGG, ChEBI KEGG, ChEBI

6 ?chebiDrug bio2rdf:image ?chebiImage ChEBI ChEBI ChEBI

The standard- and prudent decompositions of LS5 over KEGG, ChEBI and Drugbank are identical for this particular selection of datasets. The difference between them is revealed by reducing the selection to ChEBI and Drugbank only, viz. Table 3. Here, the standard decomposition assigns the subquery consisting of line 4, 5 and 6 to ChEBI, since this larger set now constitutes an exclusive group for ChEBI. Note, however, that its join-graph is not connected since none of the variables in line 4 occur in line 5 or 6. Therefore, the prudent decomposition divides ${4, 5, 6}$ into its two join-connected components ${4}$ and ${5, 6}$ which are both assigned to ChEBI, only this time as separate subqueries.

Table 3
Decompositions of LS5 over ChEBI and Drugbank

Nr. Triple pattern Even Standard Prudent

1 ?drug rdf:type drugbank:drugs Both Both Both

2 ?drug drugbank:keggCompoundId ?keggDrug Drugbank Drugbank Drugbank

3 ?drug drugbank:genericName ?drugBankName Drugbank

4 ?keggDrug bio2rdf:url ?keggUrl ChEBI ChEBI ChEBI

5 ?chebiDrug purl:title ?drugBankName ChEBI ChEBI

6 ?chebiDrug bio2rdf:image ?chebiImage ChEBI

6.2. Evaluation rules

Signature element/property	Dataset
rdf:type	All
drugbank:keggCompundId	Drugbank
drugbank:genericName	Drugbank
bio2rdf:url	KEGG, ChEBI
purl:title	KEGG, ChEBI
bio2rdf:image	ChEBI

Nr.	Triple pattern	Even	Standard	Prudent
1	?drug rdf:type drugbank:drugs	All	All	All
2	?drug drugbank:keggCompoundId ?keggDrug	Drugbank	Drugbank	Drugbank
3	?drug drugbank:genericName ?drugBankName	Drugbank
4	?keggDrug bio2rdf:url ?keggUrl	KEGG, ChEBI	KEGG, ChEBI	KEGG, ChEBI
5	?chebiDrug purl:title ?drugBankName	KEGG, ChEBI	KEGG, ChEBI	KEGG, ChEBI
6	?chebiDrug bio2rdf:image ?chebiImage	ChEBI	ChEBI	ChEBI

Nr.	Triple pattern	Even	Standard	Prudent
1	?drug rdf:type drugbank:drugs	Both	Both	Both
2	?drug drugbank:keggCompoundId ?keggDrug	Drugbank	Drugbank	Drugbank
3	?drug drugbank:genericName ?drugBankName	Drugbank
4	?keggDrug bio2rdf:url ?keggUrl	ChEBI	ChEBI	ChEBI
5	?chebiDrug purl:title ?drugBankName	ChEBI	ChEBI
6	?chebiDrug bio2rdf:image ?chebiImage	ChEBI

Turning now to the notion of an evaluation rule, it suffices to define it abstractly as a function that produces a set of answers, in the form of intercontextual joins (cf. the previous section), from a decomposition:

Definition 6.5 (Evaluation rule).

An evaluation rule is a function $E$ that takes any decomposition $δ (G, P)$ and returns a set of variable mappings $ρ : V \to ST$ .

Obviously, this definition hides great variety. Next:

Definition 6.6.
A federation scheme is a pair $(E, δ)$ consisting of an evaluation rule and a decomposition function.

The following particular evaluation rule is a generalization to a semantics parametrized by contexts of the so-called collect-and-combine rule from [35]:
Definition 6.7 (Collect-and-combine rule).

Put $Δ : = δ (G, P)$ . If δ is not defined at $G$ and P then $E^{c} (Δ) =_{df} \emptyset$ , otherwise $\begin{matrix} E^{c} (Δ) =_{df} ⋈ {{[P_{j}]}_{G_{i}} : (P_{j}, G_{i}) \in Δ} \end{matrix}$ where ${[P]}_{G} =_{df} ⟦ P ⟧_{G_{1}}^{c}, \cup \dots \cup ⟦ P ⟧_{G_{n}}^{d}$ where $G = G_{1}, \dots, G_{n}$ and $c, \dots, d$ is a vector of n distinct execution contexts.

The collect and combine rule is relatively simple if one looks beyond the bureaucracy that comes with execution contexts. It takes each element in a decomposition, executes it against each source that covers its signature, and collects the results. Then it forms the coordinatewise join of the resulting set. Peeking ahead to the next section, this rule turns out to be too simple for the case where blank nodes are involved, but may serve as a concrete example to aid intuition.

The reader should note that in order to be completely precise formally, the set ${[P]}_{G}$ ought to have had an additional parameter $C$ denoting the contexts $c, \dots, d$ . However as the sets ${[P]}_{G}^{C_{1}}$ and ${[P]}_{G}^{C_{j}}$ are simply equivalent for any choice of $C_{i}$ and $C_{j}$ and since expressions of this form will figure only as arguments to intercontextual joins, we let the contexts drop out of view at this point.

6.3. Completeness

Recapitulating briefly, the properties of soundness and completeness are relations that hold between federation schemes on the one hand and sets of selections of RDF graphs on the other. The former specifies how a graph pattern is to be distributed and evaluated, the latter defines the permissible ways of selecting sources over which to distribute the decomposed query.

One will want the federation scheme in question and the selection of sources to be perfectly matched, meaning that if a global query is processed according to the scheme it will neither invent solutions nor ignore any that are warranted by the sum total of information in the contributing sources. Recalling that sameness of solutions is defined in terms of simple equivalence, this gives the following definition of the soundness and completeness of a federation scheme wrt. to a set of selection of sources:

Definition 6.8.
Let ${G_{i}}_{i \in I}$ be a set of selections of RDF graphs. A federation scheme $(E, δ)$ is complete wrt. ${G_{i}}_{i \in I}$ if for every $i \in I$ , $μ_{c} \in ⟦ P ⟧_{G_{i}}^{c}$ implies that there is a $ρ \in E (δ (G_{i}, P))$ such that . It is sound if the converse holds.

This definition differs from that of [35] where soundness and completeness is defined in terms of set-inclusion as $E (δ (G_{i}, P)) = ⟦ P ⟧_{G_{i}}^{c}$ . Set inclusion is fine if one disregards blank nodes, i.e. assumes that there are none, for if there are no blank nodes then contexts are idle and answer sets do not need to be parameterized. The inclusion-based semantics of [5] will then be sufficiently expressive to give a characterisation of the semantics of distributed queries. In the opposite case, however, contexts are needed to keep tabs on the separate scopes for blank nodes. Therefore emphasis must be shifted from set-inclusion onto simple equivalence, as explained in Section 4. Definition 6.8 is adjusted accordingly.

Taking sets of selections of sources (that is, sets of sets of sources) as the semantic correlate of decomposition schemes facilitates the formalization of different degrees of knowledge about the structure and content of the sources that a query is distributed over. At the extreme end of this spectrum one finds the zero-knowledge case, i.e. the case where nothing is known about the tributary sources apart from their respective signatures. The zero-knowledge case, of course, corresponds to the absence of any restriction on how to make a selection of sources to distribute a query over, i.e. it corresponds to the set of all selection of sources. Stolpe [35] proves the following:
Theorem 6.2.
Suppose δ is the even-, standard or prudent decomposition. Then $(E^{c}, δ)$ is sound and complete wrt. the set of all selections of RDF graphs, provided none of the selected graphs contain blank nodes.

However, Theorem 6.2 does not generalize. That is, neither the even-, standard nor prudent decomposition guarantees completeness of query answering under the collect-and-combine rule when blank nodes are allowed (the reader may wish to refer back to the example in Section 4).

Table 4
Summary of notation

Nomenclature Description

t a triple pattern

a an assertion aka. an RDF triple

P a conjunctive graph pattern

G an RDF graph

$sig (P)$ the signature/the set of predicates of P

$Σ_{G} (P)$ the sources in $G$ whose signature cover P

$G$ a set of RDF graphs

$var (P)$ the variables occurring in P

μ partial function from variables to RDF terms

$μ_{c}$ solution mapping, blank nodes derive from c

ρ a join across multiple execution contexts

$dom (μ_{c})$ the domain of $μ_{c}$

$⟦ P ⟧_{G}^{c}$ P evaluated over G in context c

$⟦ P ⟧_{G}^{c}$ P evaluated over the union of $G$ in context c

${[P]}_{G}$ the union of evaluating P over each $G \in G$

$f (μ_{c}, P)$ the b-components of P relative to $μ_{c}$

7. A zero-knowledge complete federation scheme

Nomenclature	Description
t	a triple pattern
a	an assertion aka. an RDF triple
P	a conjunctive graph pattern
G	an RDF graph
$sig (P)$	the signature/the set of predicates of P
$Σ_{G} (P)$	the sources in $G$ whose signature cover P
$G$	a set of RDF graphs
$var (P)$	the variables occurring in P
μ	partial function from variables to RDF terms
$μ_{c}$	solution mapping, blank nodes derive from c
ρ	a join across multiple execution contexts
$dom (μ_{c})$	the domain of $μ_{c}$
$⟦ P ⟧_{G}^{c}$	P evaluated over G in context c
$⟦ P ⟧_{G}^{c}$	P evaluated over the union of $G$ in context c
${[P]}_{G}$	the union of evaluating P over each $G \in G$
$f (μ_{c}, P)$	the b-components of P relative to $μ_{c}$

Consider the following distribution function and evaluation rule:

Definition 7.1.
Let $G$ be a set of sources, P a query pattern, and put $G_{i} =_{df} Σ_{G} (P_{i})$ . Then $\begin{matrix} δ^{b} (G, P) =_{df} {(P_{i}, G_{i}) : P_{i} \subseteq P, G_{i} \neq \emptyset} \end{matrix}$

It is immediate by this definition, that if $δ^{b}$ is defined at $G$ and P then $δ^{b} (G, P)$ includes at least one partition of P. Indeed, peeking ahead to Theorem 7.1, it can be shown to contain a sufficient number of subsets of P to reconstruct any partition of P that is induced by a solution $μ_{g}$ over the merge of $G$ . This is what matters to completeness, of course.
Definition 7.2.
Let $G$ and P be as in Definition 7.1. For any distribution Δ of a query pattern P let $P (Δ)$ denote the set of partitions of P contained in Δ. Then $\begin{matrix} E^{b} (Δ) =_{df} ⋃_{{(P_{i}, G_{i})}_{i \in I} \in P (Δ)} E^{c} ({(P_{i}, G_{i})}_{i \in I}) \end{matrix}$

It should be evident that $E^{b}$ is a straightforward generalization of $E^{c}$ . More precisely, $E^{b}$ is simply the union of the results of applying $E^{c}$ to each partition of P that the distribution function delivers. We have:
Theorem 7.1.
The federation scheme $(E^{b}, δ^{b})$ is sound and complete wrt. the set of all selections of sources.
Proof.
For completeness, let $G$ be any selection of sources and suppose $μ_{g} \in ⟦ P ⟧_{G}^{g}$ . By the definition of $E^{b}$ it suffices to find a set ${(P_{i}, G_{i})}_{i \in I} \in P (Δ)$ such that there is a $ρ \in E^{c} ({(P_{i}, G_{i})}_{i \in I})$ with . Now, by Corollary 5.5 there is a partition $P_{m}, \dots, P_{n}$ of P such that, $ρ \in ⟦ P_{m} ⟧_{G_{m}}^{c_{m}} ⋈ \dots ⋈ ⟦ P_{n} ⟧_{G_{n}}^{c_{n}}$ for arbitrarily chosen $c_{1}, \dots, c_{n}$ , and . We need to show first of all that this partition is an element of $P (δ^{d} (G, P))$ . This is immediate, because $ρ \in ⟦ P_{m} ⟧_{G_{m}}^{c_{m}} ⋈ \dots ⋈ ⟦ P_{n} ⟧_{G_{n}}^{c_{n}}$ and implies that $Σ_{G} (P_{i}) \neq \emptyset$ for every $P_{i}$ thus satisfying Definition 7.1. Now, by the definition of $E^{c}$ we have $E^{c} ({(P_{i}, G_{i})}_{i \in I}) = {[P_{m}]}_{G_{m}} ⋈ \dots ⋈ {[P_{n}]}_{G_{n}}$ so it suffices to show that ρ is in the right hand side of this equality. By Definition 6.7 we have $⟦ P_{i} ⟧_{G_{i}}^{c_{i}} \subseteq {[P_{i}]}_{G_{i}}$ for every $i \in [m, n]$ . By monotony for ⋈ under set inclusion, therefore, $⟦ P_{m} ⟧_{G_{m}}^{c_{m}} ⋈ \dots ⋈ ⟦ P_{n} ⟧_{G_{n}}^{c_{n}} \subseteq {[P_{m}]}_{G_{m}} ⋈ \dots ⋈ {[P_{n}]}_{G_{n}} = E^{c} ({(P_{i}, G_{i})}_{i \in I})$ , as desired.

As for the soundness direction of the proof, this is just Lemma 4.6, so the proof is complete. □

A few comments on this result are in order: Although the completeness of $(E^{b}, δ^{b})$ is achieved, at the end of the day, by grouping together in a single subquery those triple patterns that are needed to capture a join on a blank node, this does not entail that the subqueries themselves are connected. Example 5.2 showed as much. Therefore, in the absence of knowledge about the structure of the data, the distribution function $δ^{d}$ has to cast a very wide net indeed. $δ^{d} (G, P)$ thus contains one pair for every subset of P such that the signature of P in its entirety is covered by at least one source.

When one cannot make any assumptions about the structure and content of the contributing sources, there seems to be no other solution than to evaluate all the possible partitions of the original query that involves only cells whose signature is covered by a source. Indeed, this can easily be seen to be not only a sufficient, but also a necessary condition for completeness, for if one of these partitions is skipped it is straightforward to tailor a selection of sources that correspond to just that partition.

Alas, in the limiting case where $G$ contains sources with identical signatures, the distribution $δ^{d} (G, P)$ is isomorphic to the powerset of P, which in turn means that the number of partitions that must be processed by the evaluation rule is the Bell number corresponding to the cardinality of P. This requires an exponential number of steps and so is not computationally tractable. As remarked by one of the reviewers, query evaluation is already computationally intractable, even for a single source that doesn’t contain blank nodes and even for conjunctive queries. So it is not that sound and complete decomposition makes query evaluation intractable. Rather it’s that computing the decomposition adds another exponentially hard problem to the already intractable problem of query answering.

The obvious remedy for this is to make sure that one has some knowledge about the sources, either by imposing requirements on them or by probing them. By ‘probing’ is here understood an initial round of queries, typically but not necessarily SPARQL ASK queries, designed to detect patterns in the data, typically concerning the placement of blank nodes, that can be exploited for decomposing the global query.

Recall that $f (μ_{c}, P)$ denotes the b-components of P parameterized by $μ_{c}$ . A condition that simplifies things a great deal, and that involves both regimentation and probing is the following:
Definition 7.3 (Uniformity).

A set of RDF graphs $G : = {G_{i}}_{i \in I}$ is a uniform selection of sources, or just uniform, if for all patterns P it is the case that if $μ_{c} \in ⟦ P ⟧_{G}^{c}$ and $μ_{d}^{'} \in ⟦ P ⟧_{G}^{d}$ then $f (μ_{c}, P) = f (μ_{d}^{'}, P)$ .

To be sure, uniformity is a lot to ask for. It is a global requirement that demands that the same type of information be encoded by the same graph pattern in all the sources where it occurs. Uniformity does not, however, limit the space of eligible patterns. That is, it does not say anything specific about how the data must look, only that an encoding pattern must be employed consistently across all contributing sources. This need not be as strict as it sounds, since it will be the case for instance if each source is individually consistent in this sense and if in addition the contributing sources all provide solutions to different subpatterns.

From a theoretical point of view, uniformity is interesting for two reasons: first, a very limited amount of probing suffices. In fact, a single solution to the global query is enough to determine a sound and complete federation scheme. Secondly, the evaluation rule $E^{d}$ only has to process a single partition, and thus reduces to $E^{c}$ . All this is recorded in the following simple definition and accompanying theorem:

Definition 7.4 (Induced distro).

Let $μ_{c} \in ⟦ P ⟧_{G}^{c}$ . The distribution induced by $μ_{c}$ is defined as the function $δ_{μ_{c}}$ such that $(P_{i}, G_{k}) \in δ_{μ_{c}}$ iff

$G_{k} \subseteq G$ ,

$Σ_{G} (P) = G_{k}$ , and

$P_{i} \in f (μ_{c}, P)$ .

Theorem 7.2.
Let $G$ be a uniform selection of sources. Then $(E^{c}, δ_{μ_{c}})$ is sound and complete wrt. to ${G}$ .
Proof.
Soundness is already established. For completeness, suppose $μ_{g}^{'} \in ⟦ P ⟧_{G}^{g}$ . We need to show that there is a $ρ \in E (δ_{μ_{c}} (G, P))$ such that . Clearly there is a $ρ \in E (δ_{μ_{g}^{'}} (G, P))$ with the required properties since $δ_{μ_{g}^{'}}$ is induced by $μ_{g}^{'}$ . But by uniformity $E (δ_{μ_{c}} (G, P)) = E (δ_{μ_{g}^{'}} (G, P))$ so we are done. □

Summing up, one might say that Theorems 7.1 and 7.2 constitute different extremes of a combinatorial spectrum. The former gives a complete federation scheme in which the number of required partitions of a query grows exponentially in the size of the query, whereas the latter gives a federation scheme where the number of required partitions is constant with $c = 1$ . It follows that any blend of probing and regimentation will land you somewhere in-between.

Of course, with perfect knowledge about the structure of the sources, probing will not be necessary at all. A perfect knowledge-case would be one where the contributing sources could be expected to conform to a predefined schema e.g. a resource shape [30]. In such a case, distributed query processing can be done efficiently without having to sacrifice the expressive power that comes with blank nodes.

Exploring the space between Theorems 7.1 and 7.2 should provide a rich field for future research.
8. Conclusion

It has been demonstrated that the presence of blank nodes in RDF data represents a problem for distributed processing of SPARQL queries. Even though the facts of the matter are fairly simple, they seem as yet to have slipped by unnoticed, and none of the usual decomposition strategies from the literature solve it.

To mend the situation, this paper has introduced a semantics for distributed query processing in which the notion of an execution context is explicit. This makes it possible to keep tabs on the naming of blank nodes across execution contexts, which in turn makes it possible to articulate a decomposition strategy that is provably sound and complete wrt. any selection of RDF sources even when blank nodes are allowed. Alas, this strategy is not computationally tractable. However, there are ways of utilizing knowledge about the sources, if one has it, that will help considerably.

References

Abiteboul,

Hull and

Vianu, Foundations of Databases, Addison-Wesley, 1995, http://webdam.inria.fr/Alice/. ISBN 0-201-53771-0.

Acosta and

M.-E.

Vidal, Networks of linked data eddies: An adaptive web query processing engine for RDF data, in: The Semantic Web – ISWC 2015 – 14th International Semantic Web Conference, Proceedings, Part I, Bethlehem, PA, USA, October 11–15, 2015,

Arenas,

Ó.

Corcho,

Simperl,

Strohmaier,

d’Aquin,

Srinivas,

P.T.

Groth,

Dumontier,

Heflin,

Thirunarayan and

Staab, eds, Lecture Notes in Computer Science, Vol. 9366, Springer, 2015, pp. 111–127. doi:10.1007/978-3-319-25007-6_7.

Acosta,

M.-E.

Vidal,

Lampo,

Castillo and

Ruckhaus, ANAPSID: An adaptive query processing engine for SPARQL endpoints, in: The Semantic Web – ISWC 2011 – 10th International Semantic Web Conference, Proceedings, Part I, Bonn, Germany, October 23–27, 2011,

Aroyo,

Welty,

Alani,

Taylor,

Bernstein,

Kagal,

N.F.

Noy and

Blomqvist, eds, Lecture Notes in Computer Science, Vol. 7031, Springer, 2011, pp. 18–34. doi:10.1007/978-3-642-25073-6_2.

Akar,

T.G.

Halaç,

E.E.

Ekinci and

Dikenelli, Querying the web of interlinked datasets using VOID descriptions, in: WWW2012 Workshop on Linked Data on the Web, Lyon, France, 16 April, 2012,

Bizer,

Heath,

Berners-Lee and

Hausenblas, eds, CEUR Workshop Proceedings, Vol. 937, CEUR-WS.org, 2012, http://ceur-ws.org/Vol-937/ldow2012-paper-06.pdf.

Arenas,

Gutierrez and

Pérez, Foundations of RDF databases, in: Reasoning Web. Semantic Technologies for Information Systems, 5th International Summer School 2009, Tutorial Lectures, Brixen-Bressanone, Italy, August 30–September 4, 2009,

Tessaris,

Franconi,

Eiter,

Gutierrez,

Handschuh,

M.-C.

Rousset and

R.A.

Schmidt, eds, Lecture Notes in Computer Science, Vol. 5689, Springer, 2009, pp. 158–204. doi:10.1007/978-3-642-03754-2_4.

Basca and

Bernstein, Avalanche: Putting the spirit of the web back into semantic web querying, in: Proceedings of the ISWC 2010 Posters & Demonstrations Track: Collected Abstracts, Shanghai, China, November 9, 2010,

Polleres and

Chen, eds, CEUR Workshop Proceedings, Vol. 658, CEUR-WS.org, 2010, http://ceur-ws.org/Vol-658/paper527.pdf.

Betz,

Gropengießer,

Hose and

K.-U.

Sattler, Learning from the history of distributed query processing – A heretic view on linked data management, in: Proceedings of the Third International Workshop on Consuming Linked Data, COLD 2012, Boston, MA, USA, November 12, 2012,

Sequeda,

Harth and

Hartig, eds, CEUR Workshop Proceedings, Vol. 905, CEUR-WS.org, 2012, http://ceur-ws.org/Vol-905/BetzEtAl_COLD2012.pdf.

Bizer,

Heath and

Berners-Lee, Linked data – The story so far, International Journal on Semantic Web and Information Systems 5(3) (2009), 1–22. doi:10.4018/jswis.2009081901.

Chen,

Zhang and

Zhang, Sparkrdf: Elastic discreted RDF graph processing engine with distributed memory, in: Proceedings of the ISWC 2014 Posters & Demonstrations Track a Track Within the 13th International Semantic Web Conference, ISWC 2014, Riva del Garda, Italy, October 21, 2014,

Horridge,

Rospocher and

van Ossenbruggen, eds, CEUR Workshop Proceedings, Vol. 1272, CEUR-WS.org, 2014, pp. 261–264, http://ceur-ws.org/Vol-1272/paper_43.pdf.

10.

Choi,

Son,

Cho,

M.K.

Sung and

Y.D.

Chung, SPIDER: A system for scalable, parallel/distributed evaluation of large-scale RDF data, in: Proceedings of the 18th ACM Conference on Information and Knowledge Management, CIKM 2009, Hong Kong, China, November 2–6, 2009,

D.W.-L.

Cheung,

I.-Y.

Song,

W.W.

Chu,

Hu and

J.J.

Lin, eds, ACM, 2009, pp. 2087–2088. doi:10.1145/1645953.1646315.

11.

Görlitz and

Staab, SPLENDID: SPARQL endpoint federation exploiting VOID descriptions, in: Proceedings of the Second International Workshop on Consuming Linked Data (COLD2011), Bonn, Germany, October 23, 2011,

Hartig,

Harth and

Sequeda, eds, CEUR Workshop Proceedings, Vol. 782, CEUR-WS.org, 2011, http://ceur-ws.org/Vol-782/GoerlitzAndStaab_COLD2011.pdf.

12.

Görlitz and

Staab, Federated data management and query optimization for linked open data, in: New Directions in Web Data Management 1,

Vakali and

L.C.

Jain, eds, Studies in Computational Intelligence, Vol. 331, Springer, 2011, pp. 109–137. doi:10.1007/978-3-642-17551-0_5.

13.

Harris and

Seaborne, SPARQL 1.1 query language, W3C Recommendation, 21 March 2013, https://www.w3.org/TR/sparql11-query/.

14.

Hartig, Zero-knowledge query planning for an iterator implementation of link traversal based query execution, in: The Semantic Web: Research and Applications – 8th Extended Semantic Web Conference, ESWC 2011,Proceedings, Part I, Heraklion, Crete, Greece, May 29–June 2, 2011,

Antoniou,

Grobelnik,

E.P.B.

Simperl,

Parsia,

Plexousakis,

De Leenheer and

J.Z.

Pan, eds, Lecture Notes in Computer Science, Vol. 6643, Springer, 2011, pp. 154–169. doi:10.1007/978-3-642-21034-1_11.

15.

Hartig, SPARQL for a web of linked data: Semantics and computability, in: The Semantic Web: Research and Applications – 9th Extended Semantic Web Conference, ESWC 2012, Proceedings, Heraklion, Crete, Greece, May 27–31, 2012,

Simperl,

Cimiano,

Polleres,

Ó.

Corcho and

Presutti, eds, Lecture Notes in Computer Science, Vol. 7295, Springer, 2012, pp. 8–23. doi:10.1007/978-3-642-30284-8_8.

16.

Hartig,

Bizer and

J.C.

Freytag, Executing SPARQL queries over the web of linked data, in: The Semantic Web – ISWC 2009, 8th International Semantic Web Conference, ISWC 2009, Proceedings, Chantilly, VA, USA, October 25–29, 2009,

Bernstein,

D.R.

Karger,

Heath,

Feigenbaum,

Maynard,

Motta and

Thirunarayan, eds, Lecture Notes in Computer Science, Vol. 5823, Springer, 2009, pp. 293–309. doi:10.1007/978-3-642-04930-9_19.

17.

Hartig and

Pirrò, A context-based semantics for SPARQL property paths over the web, in: The Semantic Web. Latest Advances and New Domains – 12th European Semantic Web Conference, ESWC 2015, Proceedings, Portoroz, Slovenia, May 31–June 4, 2015,

Gandon,

Sabou,

Sack,

d’Amato,

Cudré-Mauroux and

Zimmermann, eds, Lecture Notes in Computer Science, Vol. 9088, Springer, 2015, pp. 71–87. doi:10.1007/978-3-319-18818-8_5.

18.

Heath and

Bizer, Linked Data: Evolving the Web Into a Global Data Space, Synthesis Lectures on the Semantic Web, Morgan & Claypool Publishers, 2011. doi:10.2200/S00334ED1V01Y201102WBE001.

19.

Hogan,

Arenas,

Mallea and

Polleres, Everything you always wanted to know about blank nodes, Journal of Web Semantics 27 (2014), 42–69. doi:10.1016/j.websem.2014.06.004.

20.

Hose,

Schenkel,

Theobald and

Weikum, Database foundations for scalable RDF processing, in: Reasoning Web. Semantic Technologies for the Web of Data – 7th International Summer School 2011, Tutorial Lectures, Galway, Ireland, August 23–27, 2011,

Polleres,

d’Amato,

Arenas,

Handschuh,

Kroner,

Ossowski and

P.F.

Patel-Schneider, eds, Lecture Notes in Computer Science, Vol. 6848, Springer, 2011, pp. 202–249. doi:10.1007/978-3-642-23032-5_4.

21.

Huang,

D.J.

Abadi and

Ren, Scalable SPARQL querying of large RDF graphs, The Proceedings of VLDB Endowment 4(11) (2011), 1123–1134, http://www.vldb.org/pvldb/vol4/p1123-huang.pdf.

22.

M.F.

Husain,

J.P.

McGlothlin,

M.M.

Masud,

L.R.

Khan and

B.M.

Thuraisingham, Heuristics-based query processing for large RDF graphs using cloud computing, IEEE Transactions on Knowledge and Data Engineering 23(9) (2011), 1312–1327. doi:10.1109/TKDE.2011.103.

23.

Ladwig and

Tran, Sihjoin: Querying remote and local linked data, in: The Semantic Web: Research and Applications – 8th Extended Semantic Web Conference, ESWC 2011, Proceedings, Part I, Heraklion, Crete, Greece, May 29–June 2, 2011,

Antoniou,

Grobelnik,

E.P.B.

Simperl,

Parsia,

Plexousakis,

De Leenheer and

J.Z.

Pan, eds, Lecture Notes in Computer Science, Vol. 6643, Springer, 2011, pp. 139–153. doi:10.1007/978-3-642-21034-1_10.

24.

Liu,

Qu,

Qi,

Wang and

Yu, Hadoopsparql: A hadoop-based engine for multiple SPARQL query answering, in: The Semantic Web: ESWC 2012 Satellite Events – ESWC 2012 Satellite Events, Revised Selected Papers, Heraklion, Crete, Greece, May 27–31, 2012,

Simperl,

Norton,

Mladenic,

Della Valle,

Fundulaki,

Passant and

Troncy, eds, Lecture Notes in Computer Science, Vol. 7540, Springer, 2012, pp. 474–479. doi:10.1007/978-3-662-46641-4_48.

25.

S.J.

Lynden,

Kojima,

Matono and

Tanimura, Adaptive integration of distributed semantic web data, in: Databases in Networked Information Systems, 6th International Workshop, DNIS 2010, Proceedings, Aizu-Wakamatsu, Japan, March 29–31, 2010,

Kikuchi,

Sachdeva and

Bhalla, eds, Lecture Notes in Computer Science, Vol. 5999, Springer, 2010, pp. 174–193. doi:10.1007/978-3-642-12038-1_12.

26.

Montoya,

Skaf-Molli,

Molli and

M.-E.

Vidal, Federated SPARQL queries processing with replicated fragments, in: The Semantic Web – ISWC 2015 – 14th International Semantic Web Conference, Proceedings, Part I, Bethlehem, PA, USA, October 11–15, 2015,

Arenas,

Ó.

Corcho,

Simperl,

Strohmaier,

d’Aquin,

Srinivas,

P.T.

Groth,

Dumontier,

Heflin,

Thirunarayan and

Staab, eds, Lecture Notes in Computer Science, Vol. 9366, Springer, 2015, pp. 36–51. doi:10.1007/978-3-319-25007-6_3.

27.

Montoya,

M.-E.

Vidal and

Acosta, A heuristic-based approach for planning federated SPARQL queries, in: Proceedings of the Third International Workshop on Consuming Linked Data, COLD 2012, Boston, MA, USA, November 12, 2012,

Sequeda,

Harth and

Hartig, eds, CEUR Workshop Proceedings, Vol. 905, CEUR-WS.org, 2012, http://ceur-ws.org/Vol-905/MontoyaEtAl_COLD2012.pdf.

28.

Papailiou,

Konstantinou,

Tsoumakos, and

Koziris, H2RDF: Adaptive query processing on RDF data in the cloud, in: Proceedings of the 21st World Wide Web Conference, WWW 2012 (Companion Volume), Lyon, France, April 16–20, 2012,

Mille,

F.L.

Gandon,

Misselis,

Rabinovich and

Staab, eds, ACM, 2012, pp. 397–400. doi:10.1145/2187980.2188058.

29.

Quilitz and

Leser, Querying distributed RDF data sources with SPARQL, in: The Semantic Web: Research and Applications, 5th European Semantic Web Conference, ESWC 2008, Proceedings, Tenerife, Canary Islands, Spain, June 1–5, 2008,

Bechhofer,

Hauswirth,

Hoffmann and

Koubarakis, eds, Lecture Notes in Computer Science, Vol. 5021, Springer, 2008, pp. 524–538. doi:10.1007/978-3-540-68234-9_39.

30.

A.G.

Ryman,

Le Hors and

Speicher, OSLC resource shape: A language for defining constraints on linked data, in: Proceedings of the WWW2013 Workshop on Linked Data on the Web, Rio de Janeiro, Brazil, 14 May, 2013,

Bizer,

Heath,

Berners-Lee,

Hausenblas and

Auer, eds, CEUR Workshop Proceedings, Vol. 996, CEUR-WS.org, 2013, http://ceur-ws.org/Vol-996/papers/ldow2013-paper-02.pdf.

31.

Schätzle,

Przyjaciel-Zablocki,

Berberich and

Lausen, S2X: Graph-parallel querying of RDF with graphx, in: Biomedical Data Management and Graph Online Querying – VLDB 2015 Workshops, Big-O(Q) and DMAH, Revised Selected Papers, Waikoloa, HI, USA, August 31–September 4, 2015,

Wang,

Luo,

Weng,

Khan,

Mitra and

Yu, eds, Lecture Notes in Computer Science, Vol. 9579, Springer, 2015, pp. 155–168. doi:10.1007/978-3-319-41576-5_12.

32.

Schenk,

Saathoff,

Staab and

Scherp, Semaplorer – Interactive semantic exploration of data and media based on a federated cloud infrastructure, Journal of Web Semantics 7(4) (2009), 298–304. doi:10.1016/j.websem.2009.09.006.

33.

Schmidt,

Görlitz,

Haase,

Ladwig,

Schwarte and

Tran, Fedbench: A benchmark suite for federated semantic data query processing, in: The Semantic Web – ISWC 2011 – 10th International Semantic Web Conference, Proceedings, Part I, Bonn, Germany, October 23–27, 2011,

Aroyo,

Welty,

Alani,

Taylor,

Bernstein,

Kagal,

N.F.

Noy and

Blomqvist, eds, Lecture Notes in Computer Science, Vol. 7031, Springer, 2011, pp. 585–600. doi:10.1007/978-3-642-25073-6_37.

34.

Schwarte,

Haase,

Hose,

Schenkel and

Schmidt, Fedx: Optimization techniques for federated query processing on linked data, in: The Semantic Web – ISWC 2011 – 10th International Semantic Web Conference, Proceedings, Part I, Bonn, Germany, October 23–27, 2011,

Aroyo,

Welty,

Alani,

Taylor,

Bernstein,

Kagal,

N.F.

Noy and

Blomqvist, eds, Lecture Notes in Computer Science, Vol. 7031, Springer, 2011, pp. 601–616. doi:10.1007/978-3-642-25073-6_38.

35.

Stolpe, A logical characterisation of SPARQL federation, Semantic Web 6(6) (2015), 565–584. doi:10.3233/SW-140160.

36.

Vander Sande,

Verborgh,

Van Herwegen,

Mannens and

Van de Walle, Opportunistic linked data querying through approximate membership metadata, in: The Semantic Web – ISWC 2015 – 14th International Semantic Web Conference, Proceedings, Part I, Bethlehem, PA, USA, October 11–15, 2015,

Arenas,

Ó.

Corcho,

Simperl,

Strohmaier,

d’Aquin,

Srinivas,

P.T.

Groth,

Dumontier,

Heflin,

Thirunarayan and

Staab, eds, Lecture Notes in Computer Science, Vol. 9366, Springer, 2015, pp. 92–110. doi:10.1007/978-3-319-25007-6_6.

37.

Verborgh,

Hartig,

De Meester,

Haesendonck,

De Vocht,

Vander Sande,

Cyganiak,

Colpaert,

Mannens and

Van de Walle, Querying datasets on the web with high availability, in: The Semantic Web – ISWC 2014 – 13th International Semantic Web Conference, Proceedings, Part I, Riva del Garda, Italy, October 19–23, 2014,

Mika,

Tudorache,

Bernstein,

Welty,

C.A.

Knoblock,

Vrandecic,

P.T.

Groth,

N.F.

Noy,

Janowicz and

C.A.

Goble, eds, Lecture Notes in Computer Science, Vol. 8796, Springer, 2014, pp. 180–196. doi:10.1007/978-3-319-11964-9_12.

38.

Verborgh,

Vander Sande,

Colpaert,

Coppens,

Mannens and

Van de Walle, Web-scale querying through linked data fragments, in: Proceedings of the Workshop on Linked Data on the Web Co-Located with the 23rd International World Wide Web Conference (WWW 2014), Seoul, Korea, April 8, 2014,

Bizer,

Heath,

Auer and

Berners-Lee, eds, CEUR Workshop Proceedings, Vol. 1184, CEUR-WS.org, 2014, http://ceur-ws.org/Vol-1184/ldow2014_paper_04.pdf.

Distributed query processing in the presence of blank nodes

Abstract

Keywords

1. Introduction

2. Problem description

1 It is a slightly modified version of an example from [19].

4. Adding execution contexts to the SPARQL semantics

Definition 4.5. Given a μ : V ⟶ T and a context c, μ c : V ⟶ ST is defined as follows: μ c ( u ) = μ ( u ) whenever μ ( u ) ∈ IL , μ c ( u ) = c ( μ ( u ) ) otherwise. Generalizing Definition 4.2 accordingly yields. Definition 4.6 (Generalized evaluation).

Definition 5.1 (b-connectedness).

Definition 5.2 (b-component).

6.1. Examples of decomposition functions

Definition 6.5 (Evaluation rule).

6.3. Completeness

Definition 7.4 (Induced distro).

References

¹
It is a slightly modified version of an example from [19].

Definition 4.5.
Given a $μ : V ⟶ T$ and a context c, $μ_{c} : V ⟶ ST$ is defined as follows:
$μ_{c} (u) = μ (u)$ whenever $μ (u) \in IL$ ,

$μ_{c} (u) = c (μ (u))$ otherwise.

Generalizing Definition 4.2 accordingly yields.
Definition 4.6 (Generalized evaluation).