Downloads & Free Reading Options - Results

XML data projection (or pruning) is a natural optimization for main memory query engines: given a query Q over a document D, the subtrees of D that are not necessary to evaluate Q are pruned, thus producing a smaller document D'; the query Q is then executed on D', hence avoiding to allocate and process nodes that will never be reached by Q. In this article, we propose a new approach, based on types, that greatly improves current solutions. Besides providing comparable or greater precision and far lesser pruning overhead, our solution ---unlike current approaches--- takes into account backward axes, predicates, and can be applied to multiple queries rather than just to single ones. A side contribution is a new type system for XPath able to handle backward axes. The soundness of our approach is formally proved. Furthermore, we prove that the approach is also complete (i.e., yields the best possible type-driven pruning) for a relevant class of queries and Schemas. We further validate our approach using the XMark and XPathMark benchmarks and show that pruning not only improves the main memory query engine's performances (as expected) but also those of state of the art native XML databases.

Summary: crvs talks about jq, yq and xq Source: http://hackerpublicradio.org/eps.php?id=3252 Original audio: http://archive.org/download/hpr3252/hpr3252_source.ogg JSON Json is a cool little data serialization language, that allows you to easily and clearly demarcate blocks of data by nesting data structures such as lists (enclosed by square brackets) and key-value pairs or "dictionaries" (enclosed by curly braces). So that in the end you get something that looks like this { "first list" : [ "element1", "element2", {"element3" : "is another k-v pair", "but contains" : ["a" , "list", "of", "words"]}] , "this value is a string" : "1" , "and this is a number" : 23 , "and floating point" : 1.413 } Aside from: Lists are enclosed in [] and each element is separated by , Key-value pair lists are enclosed in {} and have the key and value separated by : and each pair is separated by , Keys have to strings quoted with double quotes Numbers may be left unquoted (but just in value fields) There are no restrictions to what you can do with JSON. Given how explicit the syntax is then, it makes for very easy parsing, and there are plenty of good parser out there. My favourite JSON parser is jq(1) . A canonical representation of the JSON example above can easily be obtained with jq by simply calling jq '' file.json (or piping the file through stdin, or even putting the contents properly quoted as the second argument). { "first list": [ "element1", "element2", { "element3": "is another k-v pair", "but contains": [ "a", "list", "of", "words" ] } ], "this value is a string": "1", "and this is a number": 23, "and floating point": 1.413 } You can also use jq in a shell script to obtain, for example the second element of the first list: $ jq '."first list"[1]' example.json "element2" So to get the value associated to a key you use the notation .key and to get the k-th element you use the notation [k-1] . To remove the quotes on the string you can use the -r flag which stands for raw output. jq(1) also gives you a few more functionalities that can be useful like getting the number of elements in a list with the length function. $ jq 'length' example.json 3 $ jq '."first list"[2]."but contains" | length' 4 Another useful feature is getting the list of keys from a key-value pair list which can be done with the function keys $ jq '."first list"[2] | keys[]' example.json "but contains", "element3" The query language is much much more flexible than this, but for most cases this should be enough for simple configuration querying. YAML and XML?? The yq project allows one to use the exact same syntax as jq to query, and emit (and therefore also transcode) yaml and XML, extending the usefulness of the query language. So for example looking at the previous file through yq gives: $ yq -y '' example.json first list: - element1 - element2 - element3: is another k-v pair but contains: - a - list - of - words this value is a string: '1' and this is a number: 23 and floating point: 1.413 And the output of this can be of course queried with yq itself, or can be used to feed into whatever application requires a yaml input (I guess it lacks the triple dash at the top, but that is actually the only warning I get from passing that abomination to yamllint) Similarly xq can be used to query XML files with the same language. However, to emit these files from json you need to use yq -x like so: $ yq -x '' example2.json element1 element2 is another k-v pair a list of words 1 23 1.413 where the original (modified) file example2.json looks like: { "file": { "first_list": [ "element1", "element2", { "element3": "is another k-v pair", "but_contains": [ "a", "list", "of", "words" ] } ], "this_value_is_a_string": "1", "and_this_is_a_number": 23, "and_floating_point": 1.413 } } So that the root dictionary has a single key-value pair and all the keys have no spaces in them (so that they can be made into xml tags).

Extensible Markup Language (XML) is a simple, very flexible text format derived from SGML. Originally designed to meet the challenges of large-scale electronic publishing, XML is also playing an increasingly important role in the exchange of a wide variety of data on the Web and elsewhere. XPath language is the result of an effort to provide address parts of an XML document. In support of this primary purpose, it becomes in a query language against an XML document. In this paper we present a proposal for the implementation of the XPath language in logic programming. With this aim we will describe the representation of XML documents by means of a logic program. Rules and facts can be used for representing the document schema and the XML document itself. In particular, we will present how to index XML documents in logic programs: rules are supposed to be stored in main memory, however facts are stored in secondary memory by using two kind of indexes: one for each XML tag, and other for each group of terminal items. In addition, we will study how to query by means of the XPath language against a logic program representing an XML document. It evolves the specialization of the logic program with regard to the XPath expression. Finally, we will also explain how to combine the indexing and the top-down evaluation of the logic program. To appear in Theory and Practice of Logic Programming (TPLP)"

As XML becomes ubiquitous and XML storage and processing becomes more efficient, the range of use cases for these technologies widens daily. One promising area is the integration of XML and data warehouses, where an XML-native database stores multidimensional data and processes OLAP queries written in the XQuery interrogation language. This paper explores issues arising in the implementation of such a data warehouse. We first compare approaches for multidimensional data modelling in XML, then describe how typical OLAP queries on these models can be expressed in XQuery. We then show how, regardless of the model, the grouping features of XQuery 1.1 improve performance and readability of these queries. Finally, we evaluate the performance of query evaluation in each modelling choice using the eXist database, which we extended with a grouping clause implementation.

This thesis introduces DescribeX, a powerful framework that is capable of describing arbitrarily complex XML summaries of web collections, providing support for more efficient evaluation of XPath workloads. DescribeX permits the declarative description of document structure using all axes and language constructs in XPath, and generalizes many of the XML indexing and summarization approaches in the literature. DescribeX supports the construction of heterogeneous summaries where different document elements sharing a common structure can be declaratively defined and refined by means of path regular expressions on axes, or axis path regular expression (AxPREs). DescribeX can significantly help in the understanding of both the structure of complex, heterogeneous XML collections and the behaviour of XPath queries evaluated on them. Experimental results demonstrate the scalability of DescribeX summary refinements and stabilizations (the key enablers for tailoring summaries) with multi-gigabyte web collections. A comparative study suggests that using a DescribeX summary created from a given workload can produce query evaluation times orders of magnitude better than using existing summaries. DescribeX's light-weight approach of combining summaries with a file-at-a-time XPath processor can be a very competitive alternative, in terms of performance, to conventional fully-fledged XML query engines that provide DB-like functionality such as security, transaction processing, and native storage.

Most state-of-the art approaches for securing XML documents allow users to access data only through authorized views defined by annotating an XML grammar (e.g. DTD) with a collection of XPath expressions. To prevent improper disclosure of confidential information, user queries posed on these views need to be rewritten into equivalent queries on the underlying documents. This rewriting enables us to avoid the overhead of view materialization and maintenance. A major concern here is that query rewriting for recursive XML views is still an open problem. To overcome this problem, some works have been proposed to translate XPath queries into non-standard ones, called Regular XPath queries. However, query rewriting under Regular XPath can be of exponential size as it relies on automaton model. Most importantly, Regular XPath remains a theoretical achievement. Indeed, it is not commonly used in practice as translation and evaluation tools are not available. In this paper, we show that query rewriting is always possible for recursive XML views using only the expressive power of the standard XPath. We investigate the extension of the downward class of XPath, composed only by child and descendant axes, with some axes and operators and we propose a general approach to rewrite queries under recursive XML views. Unlike Regular XPath-based works, we provide a rewriting algorithm which processes the query only over the annotated DTD grammar and which can run in linear time in the size of the query. An experimental evaluation demonstrates that our algorithm is efficient and scales well.