Yibin Chen

An Efficient Algorithm for Answering Graph Reachability Queries

Given a directed graph G, to check whether a node v is reachable from another node u through a path is often required. In a database system, such an operation is called a recursion computation or reachability checking and not efficiently supported. The reason for this is that the space to store the whole transitive closure of G is prohibitively high. In this paper, we address this issue and propose an 0(n2 + bnradic(b)) time algorithm to decompose a directed acyclic graph (DAG) into a minimized set of disjoint chains to facilitate reachability checking, where n is the number of the nodes and b is the DAGs width, defined to be the size of a largest node subset U of the DAG such that for every pair of nodes u, v isin U, there does not exist a path from u to v or from v to u. Using this algorithm, we are able to label a graph in 0(be) time and store all the labels in O(bn) space with O(logb) reachability checking time, where e is the number of the edges of the DAG. The method can also be extended to handle cyclic directed graphs. Experiments have been performed, showing that our method is promising.

Decomposing DAGs into spanning trees: A new way to compress transitive closures

Let G(V, E) be a digraph (directed graph) with n nodes and e edges. Digraph G* = (V, E*) is the reflexive, transitive closure if (v, u) ∈ E* iff there is a path from v to u in G. Efficient storage of G* is important for supporting reachability queries which are not only common on graph databases, but also serve as fundamental operations used in many graph algorithms. A lot of strategies have been suggested based on the graph labeling, by which each node is assigned with certain labels such that the reachability of any two nodes through a path can be determined by their labels. Among them are interval labelling, chain decomposition, and 2-hop labeling. However, due to the very large size of many real world graphs, the computational cost and size of labels using existing methods would prove too expensive to be practical. In this paper, we propose a new approach to decompose a graph into a series of spanning trees which may share common edges, to transform a reachability query over a graph into a set of queries over trees. We demonstrate both analytically and empirically the efficiency and effectiveness of our method.

Signature file hierarchies and signature graphs: a new index method for object-oriented databases

In this paper, we propose a new index structure for object-oriented databases. The main idea of this is a graph structure, called a signature graph, which is constructed over a signature file generated for a class and improves the search of a signature file dramatically. In addition, the signature files (accordingly, the signature graphs) can be organized into a hierarchy according to the nested structure (called the aggregation hierarchy) of classes in an object-oriented database, which leads to another significant improvements.

Tree inclusion algorithm, signatures and evaluation of path-oriented queries

In this paper, a method to evaluate path-oriented queries in document databases is proposed. The main idea of this method is to handle the evaluation of a path-oriented query as a tree inclusion problem. A new algorithm for tree-inclusion is discussed, which integrates a top-down process into a bottom-up searching strategy. On the one hand, the algorithm can be arranged to access the data on disk page-wise and fits therefore within a database environment. On the other hand, the algorithm can be combined with the signature indexing technique to cut off useless subtree inclusion checking as early as possible. Experiments have been conducted to compare this method with some existing approaches, which shows that the integration of the signatures into the top-down tree inclusion is highly promising.

On the Decomposition of Posets

In this paper, we propose an efficient algorithm to decompose a partially ordered set S into a minimum set of chains. It requires only O (k×n2) time and space, where n is the num¬ber of the elements in S and k is the size of a maximum anti¬chain of S.

On the Graph Decomposition

In this paper, we propose an efficient algorithm to decompose a directed acyclic graph (DAG) G into a minimized set of node-disjoint chains, which cover all the nodes of G. For any two nodes u and v on a chain, if u is above v then there is a path from u to v in G. The best algorithm for this problem up to now needs O(n3) time, where n is the number of the nodes of G.

A Linear-Space Top-Down Algorithm for Tree Inclusion Problem

We consider the following tree-matching problem: Given labeled, ordered trees P and T, can P be obtained from T by deleting nodes? Deleting a node v entails removing all edges incident to v and, if v has a parent u, replacing the edges from u to v by edges from u to the children of v. The best known algorithm for this problem needs O(|T|·|leaves(P)|) time and O(|leaves(P)|·min{DT, |leaves(T)|} + |T| + |P|) space, where leaves(T) (resp. leaves(P)) stands for the set of the leaves of T (resp. P), and DT (resp. DP) for the height of T (resp. P). In this paper, we present an efficient algorithm that requires O(|T|.|leaves(P)|) time and O(|T| + |P|) space.

Subtree Reconstruction, Query Node Intervals and Tree Pattern Query Evaluation *

Since the extensible markup language XML emerged as a new standard for information representation and exchange on the Internet, the problem of storing, indexing, and querying XML documents has been among the major issues of database research. In this paper, we study the tree pattern matching and discuss a new algorithm for processing ”ordered tree pattern queries”, by which not only ancestor/descendant relationships, but also left-to-right ordering of query nodes are considered. Such kind of tree matching has many applications in practice, such as the linguistic analysis, the video content-based retrieval, as well as the computational biology and the data mining. The time complexities of the new algorithm is bounded by O(|D|．|Q| + |T|．leaf(subscript Q)) and its space overhead is by O(leaf(subscript T)．leaf(subscript Q)), where T stands for a document tree, Q for a tree pattern and D is the largest data stream among all the data streams associated with the nodes in Q. Each data stream contains the database nodes that match the predicate at a node q. leaf(subscript T) (leaf(subscript Q)) represents the number of the leaf nodes of T (resp. Q). In addition, the algorithm can be adapted to an indexing environment with XB-trees being used. Experiments have been conducted, which shows that our algorithm is promising.

Tree Reconstruction and Bottom-Up Evaluation of Tree Pattern Queries

An XML tree pattern query, represented as a labeled tree, is essentially a complex selection predicate on both structure and content of an XML. Tree pattern matching has been identified as a core operation in querying XML data. However, almost all the proposed algorithms only deal with unordered trees, by which the order of siblings is not considered. In this paper, we discuss a new algorithm for processing ordered tree pattern queries, for which not only the ancestor-descendant and parent-child relationships, but also the order of siblings are significant. The time complexity of the algorithm is bounded by O(|D||Q| + |T|leafQ) and its space overhead is by O(leafTleafQ), where T stands for a document tree, Q for a tree pattern query and D is a largest data stream associated with a query node q of Q, which contains the database nodes that match the node predicate at q. leafT (leafQ) represents the number of the leaf nodes of T (resp. Q). In addition, the algorithm can be adapted to an indexing environment with XB-trees being used. Experiments have been conducted, which shows that the new algorithm is promising.