152 research outputs found
Relative Expressive Power of Navigational Querying on Graphs
Motivated by both established and new applications, we study navigational
query languages for graphs (binary relations). The simplest language has only
the two operators union and composition, together with the identity relation.
We make more powerful languages by adding any of the following operators:
intersection; set difference; projection; coprojection; converse; and the
diversity relation. All these operators map binary relations to binary
relations. We compare the expressive power of all resulting languages. We do
this not only for general path queries (queries where the result may be any
binary relation) but also for boolean or yes/no queries (expressed by the
nonemptiness of an expression). For both cases, we present the complete Hasse
diagram of relative expressiveness. In particular the Hasse diagram for boolean
queries contains some nontrivial separations and a few surprising collapses.Comment: An extended abstract announcing the results of this paper was
presented at the 14th International Conference on Database Theory, Uppsala,
Sweden, March 201
Reasoning & Querying – State of the Art
Various query languages for Web and Semantic Web data, both for practical use and as an area of research in the scientific community, have emerged in recent years. At the same time, the broad adoption of the internet where keyword search is used in many applications, e.g. search engines, has familiarized casual users with using keyword queries to retrieve information on the internet. Unlike this easy-to-use querying, traditional query languages require knowledge of the language itself as well as of the data to be queried. Keyword-based query languages for XML and RDF bridge the gap between the two, aiming at enabling simple querying of semi-structured data, which is relevant e.g. in the context of the emerging Semantic Web. This article presents an overview of the field of keyword querying for XML and RDF
Regular Queries on Graph Databases
Graph databases are currently one of the most popular paradigms for storing data. One of the key conceptual differences between graph and relational databases is the focus on navigational queries that ask whether some nodes are connected by paths satisfying certain restrictions. This focus has driven the definition of several different query languages and the subsequent study of their fundamental properties.
We define the graph query language of Regular Queries, which is a natural extension of unions of conjunctive 2-way regular path queries (UC2RPQs) and unions of conjunctive nested 2-way regular path queries (UCN2RPQs). Regular queries allow expressing complex regular patterns between nodes. We formalize regular queries as nonrecursive Datalog programs with transitive closure rules. This language has been previously considered, but its algorithmic properties are not well understood.
Our main contribution is to show elementary tight bounds for the containment problem for regular queries. Specifically, we show that this problem is 2EXPSPACE-complete. For all extensions of regular queries known to date, the containment problem turns out to be non-elementary. Together with the fact that evaluating regular queries is not harder than evaluating UCN2RPQs, our results show that regular queries achieve a good balance between expressiveness and complexity, and constitute a well-behaved class that deserves further investigation
Survey over Existing Query and Transformation Languages
A widely acknowledged obstacle for realizing the vision of the Semantic Web is the inability
of many current Semantic Web approaches to cope with data available in such diverging
representation formalisms as XML, RDF, or Topic Maps. A common query language is the first
step to allow transparent access to data in any of these formats. To further the understanding
of the requirements and approaches proposed for query languages in the conventional as well
as the Semantic Web, this report surveys a large number of query languages for accessing
XML, RDF, or Topic Maps. This is the first systematic survey to consider query languages from
all these areas. From the detailed survey of these query languages, a common classification
scheme is derived that is useful for understanding and differentiating languages within and
among all three areas
Context-Free Path Queries on RDF Graphs
Navigational graph queries are an important class of queries that canextract
implicit binary relations over the nodes of input graphs. Most of the
navigational query languages used in the RDF community, e.g. property paths in
W3C SPARQL 1.1 and nested regular expressions in nSPARQL, are based on the
regular expressions. It is known that regular expressions have limited
expressivity; for instance, some natural queries, like same generation-queries,
are not expressible with regular expressions. To overcome this limitation, in
this paper, we present cfSPARQL, an extension of SPARQL query language equipped
with context-free grammars. The cfSPARQL language is strictly more expressive
than property paths and nested expressions. The additional expressivity can be
used for modelling graph similarities, graph summarization and ontology
alignment. Despite the increasing expressivity, we show that cfSPARQL still
enjoys a low computational complexity and can be evaluated efficiently.Comment: 25 page
Querying graphs with data
Graph data is becoming more and more pervasive. Indeed, services such as Social Networks
or the Semantic Web can no longer rely on the traditional relational model, as its structure
is somewhat too rigid for the applications they have in mind. For this reason we have seen a
continuous shift towards more non-standard models. First it was the semi-structured data in the
1990s and XML in 2000s, but even such models seem to be too restrictive for new applications
that require navigational properties naturally modelled by graphs. Social networks fit into the
graph model by their very design: users are nodes and their connections are specified by graph
edges. The W3C committee, on the other hand, describes RDF, the model underlying the
Semantic Web, by using graphs. The situation is quite similar with crime detection networks
and tracking workflow provenance, namely they all have graphs inbuilt into their definition.
With pervasiveness of graph data the important question of querying and maintaining it has
emerged as one of the main priorities, both in theoretical and applied sense. Currently there
seem to be two approaches to handling such data. On the one hand, to extract the actual data,
practitioners use traditional relational languages that completely disregard various navigational
patterns connecting the data. What makes this data interesting in modern applications, however,
is precisely its ability to compactly represent intricate topological properties that envelop the
data. To overcome this issue several languages that allow querying graph topology have been
proposed and extensively studied. The problem with these languages is that they concentrate
on navigation only, thus disregarding the data that is actually stored in the database.
What we propose in this thesis is the ability to do both. Namely, we will study how query
languages can be designed to allow specifying not only how the data is connected, but also how
data changes along paths and patterns connecting it. To this end we will develop several query
languages and show how adding different data manipulation capabilities and different navigational
features affects the complexity of main reasoning tasks. The story here is somewhat
similar to the early success of the relational data model, where theoretical considerations led
to a better understanding of what makes certain tasks more challenging than others. Here we
aim for languages that are both efficient and capable of expressing a wide variety of queries of
interest to several groups of practitioners. To do so we will analyse how different requirements
affect the language at hand and at the end provide a good base of primitives whose inclusion
into a language should be considered, based on the applications one has in mind. Namely,
we consider how adding a specific operation, mechanism, or capability to the language affects
practical tasks that such an addition plans to tackle. In the end we arrive at several languages,
all of them with their pros and cons, giving us a good overview of how specific capabilities of
the language affect the design goals, thus providing a sound basis for practitioners to choose
from, based on their requirements
- …