Path Queries Research Articles

Constructing Effective Caches of Shortest Path Queries on Road Networks

How to effectively utilize caching technology to support high-performance shortest path queries on road networks has become an important research problem since the popularization of location-based services. Most of the existing methods design a statistical model to construct the cache with the shortest paths, and mainly consider the related query frequency obtained from the historical query logs. As a result, the paths in the cache may be concentrated in a few hot-spot areas of the road network, such as the prosperous areas of a city. Additionally, queries from remote areas may never be hit in the cache, which results in the cache hit ratio is not fully optimized. To address this problem, we define an effective model to quantify the effect of cached shortest paths; the model not only considers the related query frequency in the log but also the coverage of the paths on the road network. Then, we propose an efficient cache construction method to select the cached shortest paths from the query log. Furthermore, we design a hybrid index for the shortest paths in the cache, so that the efficiency of shortest path querying is significantly improved. Finally, we conduct comprehensive experimental studies on different datasets to verify that the cache hit ratio is greatly improved by using the proposed cache construction approaches.

Distributed Pregel-based provenance-aware regular path query processing on RDF knowledge graphs

With the proliferation of knowledge graphs, massive RDF graphs have been published on the Web. As an essential type of queries for RDF graphs, Regular Path Queries (RPQs) have been attracting increasing research efforts. However, the existing query processing approaches mainly focus on RPQs under the standard semantics, which cannot provide the provenance of the answer sets. We propose a distributed Pregel-based approach DP2RPQ to evaluating provenance-aware RPQs over big RDF graphs. Our method employs Glushkov automata to keep track of matching processes of RPQs in parallel. Meanwhile, three optimization strategies are devised according to the cost model, including vertex-computation optimization, message-communication reduction, and counting-paths alleviation, which can reduce the intermediate results of the basic DP2RPQ algorithm dramatically and overcome the counting-paths problem to some extent. The proposed algorithms are verified by extensive experiments on both synthetic and real-world datasets, which show that our approach can efficiently answer the provenance-aware RPQs over large RDF graphs. Furthermore, the RPQ semantics of DP2RPQ is richer than that of RDFPath, and the performance of DP2RPQ is still far better than that of RDFPath.

Comparing the expressiveness of downward fragments of the relation algebra with transitive closure on trees

Motivated by the continuing interest in the tree data model, we study the expressive power of downward navigational query languages on trees and chains. Basic navigational queries are built from the identity relation and edge relations using composition and union. We study the effects on relative expressiveness when we add transitive closure, projections, coprojections, intersection, and difference; this for Boolean queries and path queries on labeled and unlabeled structures. In all cases, we present the complete Hasse diagram. In particular, we establish, for each query language fragment that we study on trees, whether it is closed under difference and intersection.

Bridging Theory and Practice with Query Log Analysis

Since large structured query logs have recently become available, we have a new opportunity to gain insights in the types of queries that users ask. Even though such logs can be quite volatile, there are various new observations that can be made about the structure of queries inside them, on which we report here. Furthermore, building on an extensive analysis that has been done on such logs, we were able to provide a theoretical explanation why regular path queries in graph database applications behave better than worst-case complexity results suggest at first sight.

Implicit Landmark Path Indexing for Bounded Label Constrained Reachable Paths

In today’s Big Data era, a graph is an essential tool that models the semi-structured or unstructured data. Graph reachability with vertex or edge constraints is one of the basic queries to extract useful information from the graph data. From the graph reachability with constraints, we obtained the information about the existence of a path between the given two vertices satisfying the vertex or edge constraints. The problem of Label Constraint Reachability (LCR) found the existence of a path between the two given vertices such that the edge-labels along the path are the subset of the given edge-label constraint. We extended the LCR queries by considering weighted directed graphs and proposed a novel technique of finding paths for LCR queries bounded by path weight. We termed these paths as bounded label constrained reachable paths (BLCRP). We extended the landmark path indexing technique [1] by incorporating the implicit paths which satisfy the user constraints but need not satisfy the minimality of edge label sets. We solved the BLCRP by using the extended landmark path indexing and BFS based query processing. We addressed the following challenges through our proposed technique of implicit landmark path indexing in the problem of BLCRP that included (1) the need to handle exponential number of edge label combinations with an additional total path weight constraint, and (2) the need to discover a technique that finds exact reachable paths between the given vertices. This problem could be applied to real network scenarios like road networks, social networks, and protein-protein interaction networks. Our experiments and statistical analysis revealed the accuracy and efficiency of the proposed approach tested on synthetic and real datasets.

Dichotomies for Evaluating Simple Regular Path Queries

Regular path queries (RPQs) are a central component of graph databases. We investigate decision and enumeration problems concerning the evaluation of RPQs under several semantics that have recently been considered: arbitrary paths, shortest paths, paths without node repetitions (simple paths), and paths without edge repetitions (trails). Whereas arbitrary and shortest paths can be dealt with efficiently, simple paths and trails become computationally difficult already for very small RPQs. We study RPQ evaluation for simple paths and trails from a parameterized complexity perspective and define a class of simple transitive expressions that is prominent in practice and for which we can prove dichotomies for the evaluation problem. We observe that, even though simple path and trail semantics are intractable for RPQs in general, they are feasible for the vast majority of RPQs that are used in practice. At the heart of this study is a result of independent interest: the two disjoint paths problem in directed graphs is W[1]-hard if parameterized by the length of one of the two paths.

A trichotomy for regular simple path queries on graphs

We focus on the computational complexity of regular simple path queries (RSPQs). We consider the following problem RSPQ(L) for a regular language L: given an edge-labeled digraph G and two nodes x and y, is there a simple path from x to y that forms a word belonging to L? We fully characterize the frontier between tractability and intractability for RSPQ(L). More precisely, we prove RSPQ(L) is either ▪, ▪-complete or ▪-complete depending on the language L. We also provide a simple characterization of the tractable fragment in terms of regular expressions. Finally, we also discuss the complexity of deciding whether a language L belongs to the fragment above. We consider several alternative representations of L: DFAs, NFAs or regular expressions, and prove that this problem is ▪-complete for the first representation and ▪-complete for the other two.

Faster and Better Nested Dissection Orders for Customizable Contraction Hierarchies

Graph partitioning has many applications. We consider the acceleration of shortest path queries in road networks using Customizable Contraction Hierarchies (CCH). It is based on computing a nested dissection order by recursively dividing the road network into parts. Recently, with FlowCutter and Inertial Flow, two flow-based graph bipartitioning algorithms have been proposed for road networks. While FlowCutter achieves high-quality results and thus fast query times, it is rather slow. Inertial Flow is particularly fast due to the use of geographical information while still achieving decent query times. We combine the techniques of both algorithms to achieve more than six times faster preprocessing times than FlowCutter and even faster queries on the Europe road network. We show that, using 16 cores of a shared-memory machine, this preprocessing needs four minutes.

Bicriteria Rectilinear Shortest Paths Among Rectilinear Obstacles in the Plane

Given a rectilinear domain \(\mathcal {P}\) of h pairwise-disjoint rectilinear obstacles with a total of n vertices in the plane, we study the problem of computing bicriteria rectilinear shortest paths between two points s and t in \(\mathcal {P}\). Three types of bicriteria rectilinear paths are considered: minimum-link shortest paths, shortest minimum-link paths, and minimum-cost paths where the cost of a path is a non-decreasing function of both the number of edges and the length of the path. The one-point and two-point path queries are also considered. Algorithms for these problems have been given previously. Our contributions are threefold. First, we find a critical error in all previous algorithms. Second, we correct the error in a not-so-trivial way. Third, we further improve the algorithms so that they are even faster than the previous (incorrect) algorithms when h is relatively small. For example, for the minimum-link shortest paths, we obtain the following results. Our algorithm computes a minimum-link shortest \(s\)-\(t\) path in \(O(n+h\log ^{3/2} h)\) time. For the one-point queries, we build a data structure of size \(O(n+ h\log h)\) in \(O(n+h\log ^{3/2} h)\) time for a source point s, such that given any query point t, a minimum-link shortest \(s\)-\(t\) path can be computed in \(O(\log n)\) time. For the two-point queries, with \(O(n+h^2\log ^2 h)\) time and space preprocessing, a minimum-link shortest \(s\)-\(t\) path can be computed in \(O(\log n+\log ^2 h)\) time for any two query points s and t; alternatively, with \(O(n+h^2\cdot \log ^{2} h \cdot 4^{\sqrt{\log h}})\) time and \(O(n+h^2\cdot \log h \cdot 4^{\sqrt{\log h}})\) space preprocessing, we can answer each two-point query in \(O(\log n)\) time. Note that \(h^2\cdot \log ^{2} h \cdot 4^{\sqrt{\log h}}=O(h^{2+\epsilon })\) for any \(\epsilon >0\). These results are particularly interesting when h is relatively small. For example, if \(h=O(n^{1/2-\epsilon })\) for any \(\epsilon >0\), then all above results match the best results for the problems in simple rectilinear polygons, which are optimal. The complexities for the other two types of paths are slightly worse, but still linearly depend on n (in addition to g(h) for some functions g(h) of h).

Privacy-Protecting Algorithms for Digraph Shortest Path Queries

Trust relation in this work refers to permission that is given to a user at a source-host to access another user at a target-host through an authentication key with a unique fingerprint. The database owner can form a directed graph out of these trust relations, such that user-host pairs are considered nodes and fingerprints as arrows. The authors of this article present a novel protocol to query the shortest path from node A to node B, in a privacy preserving manner. The authors would like to use a cloud to perform such queries, but they do not allow the cloud to learn any information about the graph, nor the query. Also, the database owner is prevented from learning any information about the query, except that it happened.

Landmark community approximate optimal path query with pure linguistic attributes

The optimal path problem of graph data is a classical problem, but with the continuous development of information technology, the linguistic attributes of path descriptions are becoming more and more abundant. The nature of these attributes has uncertainty feature, which makes the choice of optimal path more difficult. Therefore, in order to solve this problem, this paper takes the path of large-scale graph and the uncertainty of linguistic attributes and the inconsistency of evaluation scale described as the research object and uses LWAA and landmark community technology to effectively solve the query problem of approximate optimal path. The efficiency of the algorithm is also verified by experiments.

Constrained shortest path query in a large time-dependent graph

The constrained shortest path (CSP) query over static graphs has been extensively studied, since it has wide applications in transportation networks, telecommunication networks and etc. Such networks are dynamic and evolve over time, being modeled as time-dependent graphs. Therefore, in this paper, we study the CSP query over a large time-dependent graph. Specifically, we study the point CSP (PCSP) query and interval CSP (ICSP) query. We formally prove that it is NP-complete to process a PCSP query and at least EXPSPACE to answer an ICSP query. We propose approximate sequential algorithms to answer the PCSP and ICSP queries efficiently. We also develop parallel algorithms for the queries that guarantee to scale with big time-dependent graphs. Using real-life graphs, we experimentally verify the efficiency and scalability of our algorithms.

HOLISTIC EVALUATION OF XML QUERIES WITH STRUCTURAL PREFERENCES ON AN ANNOTATED STRONG DATAGUIDE

With the emergence of XML as de facto format for storing and exchanging information over the Internet, the search for ever more innovative and effective techniques for their querying is a major and current concern of the XML database community. Several studies carried out to help solve this problem are mostly oriented towards the evaluation of so-called exact queries which, unfortunately, are likely (especially in the case of semi-structured documents) to yield abundant results (in the case of vague queries) or empty results (in the case of very precise queries). From the observation that users who make requests are not necessarily interested in all possible solutions, but rather in those that are closest to their needs, an important field of research has been opened on the evaluation of preferences queries. In this paper, we propose an approach for the evaluation of such queries, in case the preferences concern the structure of the document. The solution investigated revolves around the proposal of an evaluation plan in three phases: rewriting-evaluation-merge. The rewriting phase makes it possible to obtain, from a partitioning -transformation operation of the initial query, a hierarchical set of preferences path queries which are holistically evaluated in the second phase by an instrumented version of the algorithm TwigStack. The merge phase is the synthesis of the best results.

L1 shortest path queries in simple polygons

Let P be a simple polygon of n vertices. We consider two-point L1 shortest path queries in P. We build a data structure of O(n) size in O(n) time such that given any two query points s and t, the length of an L1 shortest path from s to t in P can be computed in O(log⁡n) time, or in O(1) time if both s and t are vertices of P, and an actual shortest path can be output in additional linear time in the number of edges of the path. To achieve the result, we propose a mountain decomposition of simple polygons, which may be interesting in its own right. Most importantly, our approach is much simpler than the previous work on this problem.

Graph Queries

We review various graph query language fragments that are both theoretically tractable and practically relevant. We focus on the most expressive one that retains these properties and use it as a stepping stone to examine the underpinnings of graph query evaluation along graph view maintenance. Further broadening the scope of the discussion, we then consider alternative processing techniques for graph queries, based on graph summarization and path query learning. We conclude by pinpointing the open research directions in this emerging area.

LL-based query answering over RDF databases

Abstract We present a method based on top-down parsing techniques for evaluating context-free path queries on RDF Graph Databases. The syntax of the query language is based on SPARQL. The language extends SPARQL by allowing the use of non-terminal symbols of a context-free grammar to specify paths on the graph. In this manner, the language subsumes the definition of regular graph patterns present in SPARQL. Our query evaluator takes an RDF graph, a context-free grammar and a declarative query, and produces tuples of values. The query evaluator proceeds in two stages: Firstly, the RDF graph is enriched with edges representing paths which correspond to strings derived by the grammar. We show that this algorithm is correct and presents a cubic worst-case run-time complexity on the number of nodes in the graph, which is an improvement over some previous work. The second stage of the evaluator uses the produced graph to identify tuples of values defined by a declarative query. In order to validate our approach, we conducted experiments by using some popular ontologies as well as synthetic databases. We compare performance results of our method with some related work.

Personalized Travel Time Prediction Using a Small Number of Probe Vehicles

Predicting the travel time of a path is an important task in route planning and navigation applications. As more GPS probe data has been collected to monitor urban traffic, GPS trajectories of the probe vehicles have been frequently used to predict path travel time. However, most trajectory-based methods rely on deploying GPS devices and collect real-time data on a large taxi fleet, which can be expensive and unreliable in smaller cities. This work deals with the problem of predicting path travel time when only a small number of cars are available. We propose an algorithm that learns local congestion patterns of a compact set of frequently shared paths from historical data. Given a travel time prediction query, we identify the current congestion patterns around the query path from recent trajectories, then infer its travel time in the near future. Driver identities are also used in predicting personalized travel time. Experimental results using 10--25 taxis in urban areas of Shenzhen, China, show that personal prediction has on average 3.4mins of error on trips of duration 10--75mins. This result improves the baseline approach of using purely historical trajectories by 16.8% on average, over four regions with various degrees of path regularity. It also outperforms a state-of-the-art travel time prediction method that uses both historical trajectories and real-time trajectories.

δ-Transitive closures and triangle consistency checking: a new way to evaluate graph pattern queries in large graph databases

Recently, graph databases have been received much attention in the research community due to their extensive applications in practice, such as social networks, biological networks, and World Wide Web, which bring forth a lot of challenging data management problems including subgraph search, shortest path queries, reachability verification, pattern matching, and so on. Among them, the graph pattern matching is to find all matches in a data graph G for a given pattern graph Q and is more general and flexible compared with other problems mentioned above. In this paper, we address a kind of graph matching, the so-called graph matching with δ, by which an edge in Q is allowed to match a path of length ≤ δ in G. In order to reduce the search space when exploring G to find matches, we propose a new index structure and a novel pruning technique to eliminate a lot of unqualified vertices before join operations are carried out. Extensive experiments have been conducted, which show that our approach makes great improvements in running time compared to existing ones.

A topographically preserved road‐network tile model and optimal routing method for virtual globes

AbstractVirtual globes enable the combination of heterogeneous datasets for optimal routing analyses in transportation, environmental ecology, and construction engineering. In this study, considering the advantages of the hierarchical tiling structure and topography of virtual globes, we propose a tile‐based optimal routing method for large‐scale road networks in a virtual globe. This method designs a topographically preserved road‐network tile model by partitioning roads into tiles and constructs the road‐network pyramid from the bottom to the top. During construction, a TileArc is calculated and flagged as the shortest path in a tile. Based on the built road‐network pyramid carrying hierarchical TileArcs, a multi‐level and flexible shortest path query can be executed efficiently. The proposed method is implemented with large road networks with different road grades in a virtual globe. Experimental results verify its validity, efficiency, and exactness. Moreover, the length of the shortest path with surface distance is approximately 1.3 times longer than that with Euclidean distance.

Evaluating Datalog via Tree Automata and Cycluits

We investigate parameterizations of both database instances and queries that make query evaluation fixed-parameter tractable in combined complexity. We show that clique-frontier-guarded Datalog with stratified negation (CFG-Datalog) enjoys bilinear-time evaluation on structures of bounded treewidth for programs of bounded rule size. Such programs capture in particular conjunctive queries with simplicial decompositions of bounded width, guarded negation fragment queries of bounded CQ-rank, or two-way regular path queries. Our result is shown by translating to alternating two-way automata, whose semantics is defined via cyclic provenance circuits (cycluits) that can be tractably evaluated.