XQuery Research Articles

A New CSRML Structure-Based Fingerprint Method for Profiling and Categorizing Per- and Polyfluoroalkyl Substances (PFAS).

The term PFAS encompasses diverse per- and polyfluorinated alkyl (and increasingly aromatic) chemicals spanning industrial processes, commercial uses, environmental occurrence, and potential concerns. With increased chemical curation, currently exceeding 14,000 structures in the PFASSTRUCTV5 inventory on EPA's CompTox Chemicals Dashboard, has come increased motivation to profile, categorize, and analyze the PFAS structure space using modern cheminformatics approaches. Making use of the publicly available ToxPrint chemotypes and ChemoTyper application, we have developed a new PFAS-specific fingerprint set consisting of 129 TxP_PFAS chemotypes coded in CSRML, a chemical-based XML-query language. These are split into two groups, the first containing 56 mostly bond-type ToxPrints modified to incorporate attachment to either a CF group or F atom to enforce proximity to the fluorinated portion of the chemical. This focus resulted in a dramatic reduction in TxP_PFAS chemotype counts relative to the corresponding ToxPrint counts (averaging 54%). The remaining TxP_PFAS chemotypes consist of various lengths and types of fluorinated chains, rings, and bonding patterns covering indications of branching, alternate halogenation, and fluorotelomers. Both groups of chemotypes are well represented across the PFASSTRUCT inventory. Using the ChemoTyper application, we show how the TxP_PFAS chemotypes can be visualized, filtered, and used to profile the PFASSTRUCT inventory, as well as to construct chemically intuitive, structure-based PFAS categories. Lastly, we used a selection of expert-based PFAS categories from the OECD Global PFAS list to evaluate a small set of analogous structure-based TxP_PFAS categories. TxP_PFAS chemotypes were able to recapitulate the expert-based PFAS category concepts based on clearly defined structure rules that can be computationally implemented and reproducibly applied to process large PFAS inventories without need to consult an expert. The TxP_PFAS chemotypes have the potential to support computational modeling, harmonize PFAS structure-based categories, facilitate communication, and allow for more efficient and chemically informed exploration of PFAS chemicals moving forward.

Metrics-Based Comparison of OWL and XML for Representing and Querying Cognitive Radio Capabilities

Collaborative spectrum access requires wireless devices to perform spectrum-related tasks (such as sensing) on request from other nodes. Thus, while joining the network, they need to inform neighboring devices and/or the central coordinator of their capabilities. During the operational phase, nodes may request other permissions from the the controller, like the opportunity to transmit according to the current policies and spectrum availability. To achieve such coordinated behavior, all associated devices within the network need a language for describing radio capabilities, requests, scenarios, policies, and spectrum availability. In this paper, we present a thorough comparison of the use of two candidate languages—Web Ontology Language (OWL) and eXtensible Markup Language (XML)—for such purposes. Towards this goal, we propose an evaluation method for automating quantitative comparisons with metrics such as precision, recall, device registration, and the query response time. The requests are expressed in both SPARQL Protocol and RDF Query Language (SPARQL) and XML Query Language (XQuery), whereas the device capabilities are expressed in both OWL and XML. The evaluation results demonstrate the advantages of using OWL semantics to improve the quality of matching results over XML. We also discuss how the evaluation method can be applicable to other scenarios where knowledge, datasets, and queries require richer expressiveness and semantics.

Considering Structural and Vocabulary Heterogeneity in XML Query: FPTPQ and Holistic Evaluation.

The integration of XML data sources which have different schemas/DTD can originate structural and vocabular heterogeneity. In this context, it is difficult to write satisfiable queries. As a solution, many Information Systems focus on building approximate evaluation techniques for exact queries. As a project, we build flexible and preference XML query languages and associated evaluation algorithms. In this paper, we propose the Flexible Preference Tree Pattern Query (FPTPQ), a new TPQ that allows multiple items/names (resp. paths) for the same node, in order to integrate (resp. to locate) all the different instances of the database nodes. The FPTPQ enable to have preference nodes and ordering operators among label items and paths. We also provide a holistic algorithm that evaluates the FPTPQ and capitalises the preferences to determine the best available solutions. Illustrations and experimentations are realized to show the effectiveness of our solutions.

TempoX: A disciplined approach for data management in multi-temporal and multi-schema-version XML databases

Although multi-temporal XML databases supporting schema versioning are used in several domains, like e-commerce, e-health, and e-government, existing database management systems and XML tools do not provide any support for managing (inserting, updating, and deleting) temporal XML data or temporal XML schema versioning. Besides, whereas much research work has focused in the last decade on schema versioning in temporal XML databases, any attention has been devoted to manipulating data in such databases. To fill this theoretical and practical gap, we propose in this paper a generic approach, named TempoX (Temporal XML), for data manipulation in multi-temporal and multi-schema-version XML databases. Indeed, we (i) define a new multi-temporal XML data model supporting temporal schema versioning, named TempoXDM (Temporal XML Data Model), (ii) introduce the principles on which our approach is based, and (iii) provide the specifications of the basic data manipulation operations: “insert”, “replace”, “evolve”, and “delete”. Moreover, to show the feasibility of TempoX, we use it to propose a temporal XML update language, named TempoXUF (Temporal XQuery Update Facility), as an extension of the W3C XQuery Update Facility language to temporal and versioning aspects. Furthermore, to validate our language proposal, we develop a system prototype, named TempoXUF-Manager, that supports TempoXUF.

Complexity of Two-Variable Logic on Finite Trees

Verification of properties expressed in the two-variable fragment of first-order logic FO 2 has been investigated in a number of contexts. The satisfiability problem for FO 2 over arbitrary structures is known to be NEXPTIME-complete, with satisfiable formulas having exponential-sized models. Over words, where FO 2 is known to have the same expressiveness as unary temporal logic, satisfiability is again NEXPTIME-complete. Over finite labelled ordered trees, FO 2 has the same expressiveness as navigational XPath, a popular query language for XML documents. Prior work on XPath and FO 2 gives a 2EXPTIME bound for satisfiability of FO 2 over trees. This work contains a comprehensive analysis of the complexity of FO 2 on trees, and on the size and depth of models. We show that different techniques are required depending on the vocabulary used, whether the trees are ranked or unranked, and the encoding of labels on trees. We also look at a natural restriction of FO 2 , its guarded version, GF 2 . Our results depend on an analysis of types in models of FO 2 formulas, including techniques for controlling the number of distinct subtrees, the depth, and the size of a witness to satisfiability for FO 2 sentences over finite trees.

One-variable context-free hedge automata

We introduce an extension of hedge automata called One-Variable Context-Free Hedge Automata. The class of unranked ordered tree languages they recognize has polynomial membership problem and is preserved by rewrite closure with inverse-monadic rules. We also propose a modeling of primitives of the W3C XQuery Update Facility by mean of parameterized rewriting rules, and show that the rewrite closure of a context-free hedge language with these extended rewriting systems is a context-free hedge language. This result is applied to static analysis of XML access control policies expressed with update primitives.

Limiting Until in Ordered Tree Query Languages

Marx and de Rijke have shown that the navigational core of the w3c XML query language XPath is not first-order complete; that is, it cannot express every query definable in first-order logic over the navigational predicates. How can one extend XPath to get a first-order complete language? Marx has shown that Conditional XPath—an extension of XPath with an “Until” operator—is first-order complete. The completeness argument makes essential use of the presence of upward axes in Conditional XPath. We examine whether it is possible to get “forward-only” languages that are first-order complete for Boolean queries on ordered trees. It is easy to see that a variant of the temporal logic CTL * is first-order complete; the variant has path quantifiers for downward, leftward, and rightward paths, while along a path one can check arbitrary formulas of Linear Temporal Logic (LTL). This language has two major disadvantages: It requires path quantification in both horizontal directions (in particular, it requires looking backward at the prior siblings of a node), and it requires the consideration of formulas of LTL of arbitrary complexity on vertical paths. This last is in contrast with Marx’s Conditional XPath, which requires only the checking of a single Until operator on a path. We investigate whether either of these restrictions can be eliminated. Our main results are negative ones. We show that if we restrict our CTL * language by having an Until operator in only one horizontal direction, then we lose completeness. We also show that no restriction to a “small” subset of LTL along vertical paths is sufficient for first-order completeness. Smallness here means of bounded “Until Depth,” a measure of complexity of LTL formulas defined by Etessami and Wilke. In particular, it follows from our work that Conditional XPath with only forward axes is not expressively complete; this extends results proved by Rabinovich and Maoz in the context of infinite unordered trees.

Static analysis of navigational XPath over graph databases

Most query languages for graph databases rely on exploring the topological properties of the data by using paths. However, many applications require more complex patterns to be matched against the graph to obtain desired results. For this reason a version of the standard XML query language XPath has been adapted to work over graphs. In this paper we study static analysis aspects of this language, concentrating on problems such as containment, equivalence and satisfiability. We show that for the full language all of the problems are undecidable. By restricting the language we then obtain several natural fragments whose complexity ranges from PSpace-complete to ExpTime-complete.

Automatic parallelization of XQuery programs on multi-core systems

The popularity of multi-core systems makes software parallelization become an important way to improve performance. As a mainstream XML query language, XQuery is the core of XML processing. It is critical to take full advantage of multi-core computing to improve XML processing performance through parallelization of XQuery. However, usually it is difficult to parallelize XQuery programs because of the nested style of XQuery expressions. Moreover, implicit parallelism is necessary to simplify the development of parallel XML application. In this paper, we propose an automatic parallelization approach, which can automatically select proper types of parallelism for a specific XQuery query. Specifically, we propose a functional intermediate language called pFXQL (parallel Functional XML Query Language) to describe parallel query plans. pFXQL has parallel semantics and is well complied with XQuery. We propose a cost model to effectively support plan generation and the selection of a preferred plan. The model estimates both computational cost and parallel cost. We implement our approach in XQuery engine and conduct experiments on various multi-core systems. Experimental results verify the effectiveness of our approach.

Comparison of two XML query languages from the perspective of learners

Two XML query languages were tested for intuitivity, learnability and memorability. The languages differ with relation to the query structures like the use of variables, iterators and reference to attributes. One of the languages, XQuery, is a procedural, expressive and data-oriented query language that is suitable even for programming purposes; the other, XIL, is more declarative, document-oriented query language with a simpler syntax. A query-writing test with the learners of the languages was executed. The study indicates that, in the query writing, the more procedural query language yields a greater number of correct queries. Similarity between the tested languages, and to SQL, is discussed from the point of view of learnability.

Validating XML document adaptations via Hedge Automata transformations

We present an automata-based method for the static analysis of user-defined XML document adaptations, expressed as sequences of update primitives of XQuery Update. The key feature of the method is the use of an automatic inference algorithm for extracting the type, expressed as a Hedge Automaton, of a sequence of document updates. The type is computed starting from the original schema S and from rewriting rules that formally define the operational semantics of a sequence of document updates. Type inclusion can then be used as a conformance test w.r.t. the type extracted from the target schema S′.

English

XML data format is widely used across devices to exchange data due to its main feature of supporting platform independency. Existing or current system used to find given keyword in XML data, a user need to know XML query language to create keyword query, submit the query for processing and get the results. In this approach user having limited knowledge about XML data, often feels complex and difficult to find require keyword in XML data and sometimes they has to use try and see approach to get relevant information. In this paper we will study different keyword based searching methods focusing on fuzzy search approach to find keyword in XML data. This searching techniques allows user explore data based on keyword as they typed even with minor mistakes in their keyword. Our survey paper helps to understand keyword based alternative method for searching XML data. Using this techniques user is able to find require sort of information from XML based file, without knowing XML query language and XML file content. Our survey paper focuses on techniques based on keyword search to retrieve top-k results, top-k algorithm to achieve high result quality and search efficiency and effective ranking method, early algorithm termination techniques while identifying top-k results and effective index structures.

Synthetising changes in XML documents as PULs

The ability of efficiently detecting changes in XML documents is crucial in many application contexts. If such changes are represented as XQuery Update Pending Update Lists (PULs), they can then be applied on documents using XQuery Update engines, and document management can take advantage of existing composition, inversion, reconciliation approaches developed in the update processing context. The paper presents an XML edit-script generator with the unique characteristic of using PULs as edit-script language and improving the state of the art from both the performance and the generated edit-script quality perspectives.

An Algorithm of XML Algebraic System Based on the Distributed Open Computing Model

The key to achieve the XML query language lies in creating valid XML algebra system. Most of the existing solutions for XML algebra system are an extension of the nested relational algebra and the major difficulty is that the computational complexity of the nested model - instance binding is too great to be effectively solved. This paper proposes an algorithm of XML algebraic system based on the distributed open computing model and then demonstrates its effectiveness in detail. By decomposing the binding process of query mode in the instance graph, this paper utilizes the message delivery to assemble the resulting tree and improve the overall computing performance. Therefore, it can provide effective support for the massive information integration and service system with the distributed open computing environment.

A controlled experiment investigation of understandability and correctness on two query languages for XML data

The study presented in this paper is a controlled experiment, aiming at investigating the understandability and correctness in two query languages, namely KINISIS against XQuery. XQuery is the W3C standard query language for XML documents. KINISIS is a graphical query language which is designed and implemented upon XQuery, using metaphors extracted from the European Road Traffic Act. We conducted a controlled experiment in order to assess users' performance, with respect to understanding and correctness, in developing queries in KINISIS and in XQuery. The findings, from the collected and statistically analysed data, showed that users performing on KINISIS had significantly better results comparing to those using XQuery. As an output of this study, is that a graphical XQuery language that is based on successful metaphors is more appropriate for novice users in XQuery technology, instead of textual XQuery.

Processing and Evaluating Partial Tree Pattern Queries on XML Data

XML query languages typically allow the specification of structural patterns using XPath. Usually, these structural patterns are in the form of trees (Tree-Pattern Queries-TPQs). Finding the occurrences of such patterns in an XML tree is a key operation in XML query evaluation. The multiple previous algorithms presented for this operation focus mainly on the evaluation of tree-pattern queries. Recently, requirements for flexible querying of XML data have motivated the consideration of query classes that are more expressive and flexible than TPQs for which efficient nonmain-memory evaluation algorithms are not known. In this paper, we consider a class of queries, called Partial Tree-Pattern Queries (PTPQs), which generalize and strictly contain TPQs. PTPQs represent a broad fragment of XPath which is very useful in practice. In order to process PTPQs, we introduce a set of sound and complete inference rules to characterize structural relationship derivation. We provide necessary and sufficient conditions for detecting query unsatisfiability and node redundancy. We also show that PTPQs can be represented as directed acyclic graphs augmented with the “same-path” constraints. In order to leverage existing efficient evaluation algorithms for less expressive classes of queries, we design two approaches that evaluate a PTPQ by decomposing it into a set of simpler queries: algorithm IndexTPQGen, exploits a structural summary of the XML data and evaluates a PTPQ by generating an equivalent set of TPQs and unioning their answers. Algorithm PartialPathJoin decomposes the PTPQ into partial-path queries, and merge-joins their solutions. We also develop PartialTreeStack, an original polynomial time holistic algorithm for PTPQs. To the best of our knowledge, this is the first algorithm to support the evaluation of such a broad structural fragment of XPath in the inverted lists evaluation model. We provide a theoretical analysis of our algorithm and identify cases where it is asymptotically optimal. An extensive experimental evaluation shows that it is more efficient, robust, and stable than the other two and it outperforms a state-of-the art XQuery engine on PTPQs.

Automata-based Static Analysis of XML Document Adaptation

The structure of an XML document can be optionally specified by means of XML Schema, thus enabling the exploitation of structural information for efficient document handling. Upon schema evolution, or when exchanging documents among different collections exploiting related but not identical schemas, the need may arise of adapting a document, known to be valid for a given schema S, to a target schema S'. The adaptation may require knowledge of the element semantics and cannot always be automatically derived. In this paper, we present an automata-based method for the static analysis of user-defined XML document adaptations, expressed as sequences of XQuery Update update primitives. The key feature of the method is the use of an automatic inference method for extracting the type, expressed as a Hedge Automaton, of a sequence of document updates. The type is computed starting from the original schema S and from rewriting rules that formally define the operational semantics of a sequence of document updates. Type inclusion can then be used as conformance test w.r.t. the type extracted from the target schema S'.

FoXtrot

Publish/subscribe systems have emerged in recent years as a promising paradigm for offering various popular notification services. In this context, many XML filtering systems have been proposed to efficiently identify XML data that matches user interests expressed as queries in an XML query language like XPath. However, in order to offer XML filtering functionality on an Internet-scale, we need to deploy such a service in a distributed environment, avoiding bottlenecks that can deteriorate performance. In this work, we design and implement FoXtrot, a system for filtering XML data that combines the strengths of automata for efficient filtering and distributed hash tables for building a fully distributed system. Apart from structural-matching, performed using automata, we also discuss different methods for evaluating value-based predicates. We perform an extensive experimental evaluation of our system, FoXtrot, on a local cluster and on the PlanetLab network and demonstrate that it can index millions of user queries, achieving a high indexing and filtering throughput. At the same time, FoXtrot exhibits very good load-balancing properties and improves its performance as we increase the size of the network.

Using XQuery for problem solving

SUMMARYXQuery is a recommendation by the World Wide Web Consortium as a standard XML query language. In addition to being a special‐purpose query language, XQuery has also features that support unexpected applications such as problem solving. We demonstrate and discuss these features by presenting several XQuery programs for solving recreational problems and puzzles. Copyright © 2011 John Wiley & Sons, Ltd.

Efficient Processing of XML Path Queries Using BI Index

XML has been widely used for information exchange and storage as the de facto data representation format nowadays. Several XML query languages such XPath, XQuery and XML-QL have been proposed. Many structural join algorithms have been proposed for processing XPath queries, Although holistic twig join algorithms has been proved to be I/O optimal in terms of input and output sizes for queries with only ancestor-descendant edges, it cannot control the size of intermediate results for queries with parent-child edges. We address the problem of efficient path queries with mixed of ancestor-descendant and parent-child edges on a simple but novel index, called BI (i.e. Binary Index) based on Dewey labeling scheme. And we propose a new holistic path join algorithm, namely PSBI, which has the same performance as PathStack for query path with only ancestor-descendant edges, but it is significantly more efficient than PathStack for queries with the presence of parent-child edges. Experimental results demonstrate that the PSBI and BI index has a substantial performance improvement compared to original PathStack algorithm.