Descendant Axes Research Articles

Robust and scalable content-and-structure indexing

Frequent queries on semi-structured hierarchical data are Content-and-Structure (CAS) queries that filter data items based on their location in the hierarchical structure and their value for some attribute. We propose the Robust and Scalable Content-and-Structure (RSCAS) index to efficiently answer CAS queries on big semi-structured data. To get an index that is robust against queries with varying selectivities, we introduce a novel dynamic interleaving that merges the path and value dimensions of composite keys in a balanced manner. We store interleaved keys in our trie-based RSCAS index, which efficiently supports a wide range of CAS queries, including queries with wildcards and descendant axes. We implement RSCAS as a log-structured merge tree to scale it to data-intensive applications with a high insertion rate. We illustrate RSCAS’s robustness and scalability by indexing data from the Software Heritage (SWH) archive, which is the world’s largest, publicly available source code archive.

Dynamic interleaving of content and structure for robust indexing of semi-structured hierarchical data

We propose a robust index for semi-structured hierarchical data that supports content-and-structure (CAS) queries specified by path and value predicates. At the heart of our approach is a novel dynamic interleaving scheme that merges the path and value dimensions of composite keys in a balanced way. We store these keys in our trie-based Robust Content-And-Structure index, which efficiently supports a wide range of CAS queries, including queries with wildcards and descendant axes. Additionally, we show important properties of our scheme, such as robustness against varying selectivities, and demonstrate improvements of up to two orders of magnitude over existing approaches in our experimental evaluation.

Model Theory of XPath on Data Trees. Part I: Bisimulation and Characterization

We investigate model theoretic properties of XPath with data (in)equality tests over the class of data trees, i.e., the class of trees where each node contains a label from a finite alphabet and a data value from an infinite domain. We provide notions of (bi)simulations for XPpath logics containing the child, parent, ancestor and descendant axes to navigate the tree. We show that these notions precisely characterize the equivalence relation associated with each logic. We study formula complexity measures consisting of the number of nested axes and nested subformulas in a formula; these notions are akin to the notion of quantifier rank in first-order logic. We show characterization results for fine grained notions of equivalence and (bi)simulation that take into account these complexity measures. We also prove that positive fragments of these logics correspond to the formulas preserved under (non-symmetric) simulations. We show that the logic including the child axis is equivalent to the fragment of first-order logic invariant under the corresponding notion of bisimulation. If upward navigation is allowed the characterization fails but a weaker result can still be established. These results hold both over the class of possibly infinite data trees and over the class of finite data trees. Besides their intrinsic theoretical value, we argue that bi-simulations are useful tools to prove (non)expressivity results for the logics studied here, and we substantiate this claim with examples.

XPath fragments on XML in columns

Purpose – This paper considers schemaless XML data stored in a column-oriented storage, particularly in C-store. Axes of the XPath language are studied and a design and analysis of algorithms for processing the XPath fragment XP{*, //, /} are described in detail. The paper aims to discuss these issues. Design/methodology/approach – A two-level model of C-store based on XML-enabled relational databases is supposed. The axes of XPath language in this environment have been studied by Cástková and Pokorný. The associated algorithms have been used for the implementation of the XPath fragment XP{*, //, /}. Findings – The main advantage of this approach is algorithms implementing axes evaluations that are mostly of logarithmic complexity in n, where n is the number of nodes of XML tree associated with an XML document. A low-level memory system enables the estimation of the number of two abstract operations providing an interface to an external memory. The algorithms developed are mostly of logarithmic complexity in n, where n is the number of nodes of XML tree associated with an XML document. Originality/value – The paper extends the approach of querying XML data stored in a column-oriented storage to the XPath fragment using only child and descendant axes and estimates the complexity of evaluating its queries.

Decidability of Downward XPath

We investigate the satisfiability problem for downward-XPath, the fragment of XPath that includes the child and descendant axes, and tests for (in)equality of attributes’ values. We prove that this problem is decidable, EXPTIME-complete. These bounds also hold when path expressions allow closure under the Kleene star operator. To obtain these results, we introduce a Downward Data automata model (DD automata) over trees with data, which has a decidable emptiness problem. Satisfiability of downward-XPath can be reduced to the emptiness problem of DD automata and hence its decidability follows. Although downward-XPath does not include any horizontal axis, DD automata are more expressive and can perform some horizontal tests. Thus, we show that the satisfiability remains in EXPTIME even in the presence of the regular constraints expressible by DD automata. However, the same problem in the presence of any regular constraint is known to have a nonprimitive recursive complexity. Finally, we give the exact complexity of the satisfiability problem for several fragments of downward-XPath.

Rewriting XPath queries using materialized XPath views

Let XP(/,//,[]) be the fragment of XPath 1.0, consisting of queries that involve only the child and descendant axes, and predicates without disjunction or negation (and no wildcard nodetests); these queries can be represented as tree patterns. We consider the problem of rewriting a query Q using a materialized view V, where Q,V∈XP(/,//,[]). We present more efficient algorithms for the following: (1) Determine if an equivalent rewriting of Q using V exists; find the smallest such rewriting, when it exists. A previously-known algorithm runs in O(|Q|2+|Q||V|) time. For the special case when Q is known to be minimal, we present an O(|Q||V|) algorithm. (2) Determine if a (nonempty) contained rewriting of Q using V exists. We present an O(|Q||V|) algorithm, compared to the previous O(|Q||V|2) algorithm. We also present a more efficient algorithm for finding a maximal such rewriting, when it exists. Then we extend this result to a subset of XP(/,//,[],⁎) that allows restricted occurrences of wildcard nodetests.

Faster bit-parallel algorithms for unordered pseudo-tree matching and tree homeomorphism

In this paper, we consider the unordered pseudo-tree matching problem, which is a problem of, given two unordered labeled trees P and T, finding all occurrences of P in T via such many-to-one matchings that preserve node labels and parent–child relationship. This problem is closely related to the tree pattern matching problem for XPath queries with child axis only. If m>w, we present an efficient algorithm that solves the problem in O(nmlog(w)/w) time using O(hm/w+mlog(w)/w) space and O(mlog(w)) preprocessing on a unit-cost arithmetic RAM model with addition, where m is the number of nodes in P, n is the number of nodes in T, h is the height of T, and w is the word length, and we assume that w⩾logn. We also discuss a modification of our algorithm for the unordered tree homeomorphism problem, which corresponds to the tree pattern matching problem for XPath queries with descendant axis only.

Bag equivalence of tree patterns

When a query is evaluated under bag semantics, each answer is returned as many times as it has derivations. Bag semantics has long been recognized as important, especially when aggregation functions will be applied to query results. This article is the first to focus on bag semantics for tree pattern queries. In particular, the problem of bag equivalence of a large class of tree pattern queries (which can be used to model XPath) is explored. The queries can contain unions, branching, label wildcards, the vertical child and descendant axes, the horizontal following and following-sibling axes, as well as positional (i.e., first and last) axes. Equivalence characterizations are provided, and their complexity is analyzed. As the descendant axis involves a recursive relationship, this article is also the first to address bag equivalence over recursive queries, in any setting.

Secure XML querying based on authorization graphs

XML is rapidly emerging as a standard for data representation and exchange over the World Wide Web and an increasing amount of sensitive business data is processed in XML format. Therefore, it is critical to have control mechanisms to restrict a user to access only the parts of XML documents that she is authorized to access. In this paper, we propose the first DTD-based access control model that employs graph matching to analyze if an input query is fully acceptable, fully rejectable, or partially acceptable. In this way, there will be no further security overhead for the processing of fully acceptable and rejectable queries. For partially acceptable queries, we propose a graph-matching based authorization model for an optimized rewriting procedure in which a recursive query (query with descendant axis `//') will be rewritten into an equivalent recursive one if possible and into a non-recursive one only if necessary, resulting queries that can fully take advantage of structural join based query optimization techniques. Moreover, we propose an index structure for XML element types to speed up the query rewriting procedure, a facility that is potentially useful for applications with large DTDs. Our performance study results showed that our algorithms armed with rewriting indexes are promising.

Memory lower bounds for XPath evaluation over XML streams

We consider the XPath evaluation problem: Evaluate an XPath query Q on a streaming XML document D. We consider two versions of the problem: 1) Filtering Problem: Determine if there is a match for Q in D. 2) Node Selection Problem: Determine the set Q ( D ) of document nodes selected by Q. We consider Conjunctive XPath ( CXPath) queries that involve only the child and descendant axes. Let d denote the depth of D, and n denote the number of location steps in Q. Bar-Yossef et al. (2007, 2005) [6,7] presented lower bounds on the memory space required by any algorithm to solve these two problems. Their lower bounds apply to each query in a large subset of XPath, and are obtained (mostly) using nonrecursive ( Q , D ) . In this paper, we present larger lower bounds for a different class of queries (namely, CXPath queries with independent predicates), on recursive ( Q , D ) . One of our results is an Ω ( n ⋅ maxcands ( Q , D ) ) lower bound for the node selection problem, for a worst-case Q; maxcands ( Q , D ) is the maximum number of nodes of D that can be candidates for output, at any one instant. So, there is no algorithm for the node selection problem that uses O ( f ( d , | Q | ) + maxcands ( Q , D ) ) space, for any function f. This shows that some previously published algorithms are incorrect.

A bi-labeling based XPath processing system

We present BLAS, a Bi-LAbeling based XPath processing System. BLAS uses two labeling schemes to speed up query processing: P-labeling for processing consecutive child (or parent) axis traversals, and D-labeling for processing descendant (or ancestor) axis traversals. XML data are stored in labeled form and indexed. Algorithms are presented for translating XPath queries to SQL expressions. BLAS reduces the number of joins in the SQL query translated from a given XPath query and reduces the number of disk accesses required to execute the SQL query compared with the traditional XPath processing using D-labeling alone. We also propose an approximate P-labeling scheme and the corresponding query translation algorithm to handle XML data trees that contain a large number of distinct tag names, and/or are very deep. This extension captures a spectrum of XPath-to-SQL query translation schemes, ranging from existing schemes that do not use P-labels to the one that uses exact P-labels. Experimental results demonstrate the efficiency of the BLAS system.

Worst-case optimal algorithm for XPath evaluation over XML streams

We consider the XPath evaluation problem: Evaluate an XPath query Q on a streaming XML document D; i.e., determine the set Q ( D ) of document elements selected by Q. We mainly consider Conjunctive XPath queries that involve only the child and descendant axes. Previously known in-memory algorithms for this problem use O ( | D | ) space and O ( | Q | | D | ) time. Several previously known algorithms for the streaming version use Ω ( d n ) space and Ω ( d n | D | ) time in the worst case; d denotes the depth of D, and n denotes the number of location steps in Q. Their exponential space requirement could well exceed the O ( | D | ) space used by the in-memory algorithms. We present an efficient algorithm that uses O ( d | Q | + n c ) space and O ( ( | Q | + d n ) | D | ) time in the worst case; c denotes the maximum number of elements of D that can be candidates for output, at any one instant. For some worst case Q and D, the memory space used by our algorithm matches our lower bound proved in a different paper; so, our algorithm uses optimal memory space in the worst case.

XML-document-filtering automaton

In a publish-subscribe system based on filtering of XML documents subscribers specify their interests with profiles expressed in the XPath language. The system processes a stream of XML documents and delivers to subscribers a notification or content of documents that match the profiles. We present a new XML-document-filtering algorithm that is based on the classic Aho-Corasick pattern-matching automaton. The automaton has a size linear in the sum of the sizes of the filters. We assume that the XML documents all conform to a given DTD; our algorithm utilizes the DTD in the preprocessing phase of the automaton to prune out descendant axes (//) and wildcards (*) from the XPath filters. The XPath subset currently supported consists of linear XPath expressions without predicates. In the case of a 683 MB protein-sequence database, we obtained a throughput of 18.8 MB/sec for 50 000 filters and 17.0 MB/sec for 500 000 filters, using a SAX parser with a throughput of 27 MB/sec.

An Efficient Bottom-up Filtering of XML Messages by Exploiting the Postfix Commonality of XPath Queries

Recently, for more efficient filtering of XML data, YFilter system has been suggested to exploit the prefix commonalities that exist among path expressions. Sharing the prefix commonality gives the benefit of improving filtering performance through the tremendous reduction in filtering machine size. However, exploiting the postfix commonality can also be useful for an XML filtering situation. For example, when a stream of XML messages does not have any defined schema, or users cannot remember the defined schema exactly, users often use the partial matching path queries which begins with the descendant axis (“//”), e.g., '//science/article/title', '//entertainment/article/title', and '//title'. If so, the registered XPath queries are most likely to have the postfix commonality, e.g., the sample queries share the partial path expressions 'article/title' and 'title'. Therefore, in this paper, we introduce a bottom-up filtering approach exploiting the postfix commonality against the top-down approach of YFilter exploiting the prefix commonality. Some experimental results show that our method has better filtering performance when registered XPath queries mainly consist of the partial matching path queries with the postfix commonality.

Efficient algorithm for XML query based sequence matching-SCALER+

The problems of SequenCe bAsed XML QuEry AlgoRithm(SCALER)were solved.The first was definitely supporting wildcard and descendant axis //,and the second was supporting queries of pattern trees with out-of-order brother nodes.The extended algorithm was named SCALER+.Experimental results prove that it is efficient as SCALER and stronger for twig query evaluation.

HCH for Checking Containment of XPath Fragment

XPath is ubiquitous in XML applications for navigating XML trees and selecting a set of element nodes. In XPath query processing, one of the most important issues is how to efficiently check containment relationship between two XPath expressions. To get out of the intricacy and complexity caused by numerous XPath features, we investigate this issue on a frequently used fragment of XPath expressions that consists of node tests, the child axis (/), the descendant axis (//), branches ([]) and label wildcards (*). Prior work has shown that homomorphism technology can be used for containment checking. However, homomorphism is the sufficient but not necessary condition for containment. For special classes of this fragment, the homomorphism algorithm returns false negatives. To address this problem, this paper proposes two containment techniques, conditioned homomorphism and hidden conditioned homomorphism, and then presents sound algorithms for checking containment. Experimental results confirm the practicability and efficiency of the proposed algorithms.

Scrap your boilerplate with XPath-like combinators

XML programming involves idioms for expressing 'structure shyness' such as the descendant axis of XPath or the default templates of XSLT. We initiate a discussion of the relationships between such XML idioms and generic functional programming, while focusing on the (Haskell-based) 'Scrap your boilerplate' style of generic programming (SYB). This work gives insight into mechanisms for traversal and selection. We compare SYB and XSLT. We approximate XPath in SYB. We make a case for SYB's programmability, when compared to XPath's fixed combinators. We allude to strengthened type checking for SYB traversals so as to reject certain, trivial behaviors.

Holistic Join for Generalized Tree Patterns

We consider the problem of evaluating an XQuery query Q (involving only child and descendant axes) on an XML document D. D is stored on a disk and is read from there, in document order. Chen et al. [From Tree Patterns to Generalized Tree Patterns: on efficient evaluation of XQuery, Proceedings of International Conference on Very Large Data Bases (VLDB), 2003, pp. 237–248] presented an algorithm to convert Q (from a large fragment of XQuery) into a Generalized Tree Pattern GTP ( Q ) , and a set J ( Q ) of value join conditions on its vertices. Evaluating Q on D reduces to finding the matches for GTP ( Q ) in D. We present an efficient algorithm for finding these matches. Excluding the computation of the value joins J ( Q ) , our algorithm performs two linear passes over the data, and runs in O ( d | Q | ) memory space, where d denotes the depth of D; runtime and disk I/O are O ( | Q ∥ D | ) . If separate input streams of document nodes for the individual vertices in GTP ( Q ) are available, our runtime and disk I/O are linear in the input size; this runtime and disk I/O are trivially optimal.

On the complexity of XPath containment in the presence of disjunction, DTDs, and variables

XPath is a simple language for navigating an XML-tree and returning a set of answer nodes. The focus in this paper is on the complexity of the containment problem for various fragments of XPath. We restrict attention to the most common XPath expressions which navigate along the child and/or descendant axis. In addition to basic expressions using only node tests and simple predicates, we also consider disjunction and variables (ranging over nodes). Further, we investigate the containment problem relative to a given DTD. With respect to variables we study two semantics, (1) the original semantics of XPath, where the values of variables are given by an outer context, and (2) an existential semantics introduced by Deutsch and Tannen, in which the values of variables are existentially quantified. In this framework, we establish an exact classification of the complexity of the containment problem for many XPath fragments.

Filtering XPath expressions for XML access control

XPath is a standard for specifying parts of XML documents and a suitable language for both query processing and access control of XML. In this paper, we use the XPath expression for representing user queries and access control for XML. And we propose an access-control method for XML, where we control accesses to XML documents by filtering query XPath expressions through access-control XPath expressions. For filtering the access-denied parts out of query XPath expressions, set operations (such as, intersection and difference) between the XPath expressions are essential. However, it is known that the containment problem of two XPath expressions is coNP-hard when the XPath expressions contain predicates (or branch), wildcards and descendant axes. To solve the problem, we directly search XACT (XML Access Control Tree) for a query XPath expression and extract the access-granted parts. The XACT is our proposed structure, where the edges are structural summary of XML elements and the nodes contain access-control information. We show that the query XPath expressions are successfully filtered through the XACT by our proposed method, and also show the performance improvement by comparing the proposed method with the previous work.