Commercial RDBMS Research Articles

Full-fledged semantic indexing and querying model designed for seamless integration in legacy RDBMS

In the past decade, there has been an increasing need for semantic-aware data search and indexing in textual (structured and NoSQL) databases, as full-text search systems became available to non-experts where users have no knowledge about the data being searched and often formulate query keywords which are different from those used by the authors in indexing relevant documents, thus producing noisy and sometimes irrelevant results. In this paper, we address the problem of semantic-aware querying and provide a general framework for modeling and processing semantic-based keyword queries in textual databases, i.e., considering the lexical and semantic similarities/disparities when matching user query and data index terms. To do so, we design and construct a semantic-aware inverted index structure called SemIndex, extending the standard inverted index by constructing a tightly coupled inverted index graph that combines two main resources: a semantic network and a standard inverted index on a collection of textual data. We then provide a general keyword query model with specially tailored query processing algorithms built on top of SemIndex, in order to produce semantic-aware results, allowing the user to choose the results' semantic coverage and expressiveness based on her needs. To investigate the practicality and effectiveness of SemIndex, we discuss its physical design within a standard commercial RDBMS allowing to create, store, and query its graph structure, thus enabling the system to easily scale up and handle large volumes of data. We have conducted a battery of experiments to test the performance of SemIndex, evaluating its construction time, storage size, query processing time, and result quality, in comparison with legacy inverted index. Results highlight both the effectiveness and scalability of our approach.

Rewriting and Executing Faceted Queries over Ontology-Enhanced Databases

Faceted search is an attractive and user friendly information retrieval paradigm. It combines two traditional approaches, namely keyword search (allowing the direct search) and navigational search (allowing for browsing the information space by iteratively narrowing the scope). In creating a faceted query, the user is provided with a tree-shaped faceted interface, which is a hierarchical view of an ontology describing the information domain. In this paper, we discuss a transformation and translation process leading from a graphical form of a faceted query, through first order forms (without and with rewriting) to a SQL query. The crucial in this is the mapping of the ontology into a relational database, and translating to SQL. In DAFO system we have used a commercial RDBMS with optimization capabilities. We report our experimental results which show very promising execution times.

Stars on steroids: Fast evaluation of multi-source star twig queries in path materialization-based XML databases

Despite a large body of work on XML twig query processing in relational environment, systematic study of XML join evaluation has received little attention in the literature. In this paper, we propose a novel and non-traditional technique for fast evaluation of multi-source star twig queries in a path materialization-based RDBMS. A multi-source star twig joins different XML documents on values in their nodes and the XQuery graph takes a star-shaped structure. Such queries are prevalent in several domains such as life sciences. Rather than following the conventional approach of generating one huge complex SQL query from a twig query, we translate a star query into a list of SQL sub-queries that only materializes minimal information of underlying XML subtrees as intermediate results. We have implemented this scheme on top of a path materialization-based XML storage system called SUCXENT++. Experiments carried out confirm that our proposed approach built on top of an off-the-shelf commercial RDBMS has excellent real-world performance.

The vertica analytic database

This paper describes the system architecture of the Vertica Analytic Database (Vertica), a commercialization of the design of the C-Store research prototype. Vertica demonstrates a modern commercial RDBMS system that presents a classical relational interface while at the same time achieving the high performance expected from modern "web scale" analytic systems by making appropriate architectural choices. Vertica is also an instructive lesson in how academic systems research can be directly commercialized into a successful product.

ANDES: efficient evaluation of NOT-twig queries in relational databases

Despite a large body of work on XPath query processing in relational environment, systematic study of queries containing not-predicates have received little attention in the literature. Particularly, several xml supports of industrial-strength commercial rdbms fail to efficiently evaluate such queries. In this paper, we present an efficient and novel strategy to evaluate not -twig queries in a tree-unaware relational environment. not -twig queries are XPath queries with ancestor---descendant and parent---child axis and contain one or more not-predicates. We propose a novel Dewey-based encoding scheme called Andes (ANcestor Dewey-based Encoding Scheme), which enables us to efficiently filter out elements satisfying a not-predicate by comparing their ancestor group identifiers. In this approach, a set of elements under the same common ancestor at a specific level in the xml tree is assigned same ancestor group identifier. Based on this scheme, we propose a novel sql translation algorithm for not-twig query evaluation. Experiments carried out confirm that our proposed approach built on top of an off-the-shelf commercial rdbms significantly outperforms state-of-the-art relational and native approaches. We also explore the query plans selected by a commercial relational optimizer to evaluate our translated queries in different input cardinality. Such exploration further validates the performance benefits of Andes.

Faking It

CPUs are no longer getting faster. Instead, CPU manufacturers now package multiple cores in each CPU and ask us developers to put them to good use. Writing parallel code using multiple threads or even a higher-level API is a fiendishly difficult task. An alternative approach involves using a programming language that can easily exploit multiple cores, but it requires substantial effort. A third way involves faking your application's multicore-handling dexterity by handing over this responsibility. At the highest level, it's easy to put multiple cores to work if your application serves Web requests (pass them to a Web application server) or dishes out SQL statements (via a commercial RDBMS). Another high-level way to utilize multiple cores is to let the operating system do it for you by splitting your processing among independent processes. You can do this by using pipelines of communicating processes, by splitting the work among many instances of the same process with GNU parallel, or by parallelizing independent work items with make -j. At the application level, you can do the same by employing the map-reduce and filter-reduce techniques.

Query translation from XPath to SQL in the presence of recursive DTDs

We study the problem of evaluating xpath queries over xml data that is stored in an rdbms via schema-based shredding. The interaction between recursion (descendants-axis) in xpath queries and recursion in dtds makes it challenging to answer xpath queries using rdbms. We present a new approach to translating xpath queries into sql queries based on a notion of extended XP ath expressions and a simple least fixpoint (lfp) operator. Extended xpath expressions are a mild extension of xpath, and the lfp operator takes a single input relation and is already supported by most commercial rdbms. We show that extended xpath expressions are capable of capturing both dtd recursion and xpath queries in a uniform framework. Furthermore, they can be translated into an equivalent sequence of sql queries with the lfp operator. We present algorithms for rewriting xpath queries over a (possibly recursive) dtd into extended xpath expressions and for translating extended xpath expressions to sql queries, as well as optimization techniques. The novelty of our approach consists in its capability to answer a large class of xpath queries by means of only low-end rdbms features already available in most rdbms, as well as its flexibility to accommodate existing relational query optimization techniques. In addition, these translation algorithms provide a solution to query answering for certain (possibly recursive) xml views of xml data. Our experimental results verify the effectiveness of our techniques.

A Conceptual Schema Language for the Management of Multiple Representations of Geographic Entities

AbstractMultiple representation of geographic information occurs when a real‐world entity is represented more than once in the same or different databases. This occurs frequently in practice, and it invariably results in the occurrence of inconsistencies among the different representations of the same entity. In this paper, we propose an approach to the modeling of multiple represented entities, which is based on the relationships among the entities and their representations. Central to our approach is the Multiple Representation Schema Language that, by intuitive and declarative means, is used to specify rules that match objects representing the same entity, maintain consistency among these representations, and restore consistency if necessary. The rules configure a Multiple Representation Management System, the aim of which is to manage multiple representations over a number of autonomous federated databases. We present a graphical and a lexical binding to the schema language. The graphical binding is built on an extension to the Unified Modeling Language and the Object Constraint Language. We demonstrate that it is possible to implement the constructs of the schema language in the object‐relational model of a commercial RDBMS.

Storing and querying XML data using denormalized relational databases

XML database systems emerge as a result of the acceptance of the XML data model. Recent works have followed the promising approach of building XML database management systems on underlying RDBMS’s. Achieving query processing performance reduces to two questions: (i) How should the XML data be decomposed into data that are stored in the RDBMS? (ii) How should the XML query be translated into an efficient plan that sends one or more SQL queries to the underlying RDBMS and combines the data into the XML result? We provide a formal framework for XML Schema-driven decompositions, which encompasses the decompositions proposed in prior work and extends them with decompositions that employ denormalized tables and binary-coded XML fragments. We provide corresponding query processing algorithms that translate the XML query conditions into conditions on the relational tables and assemble the decomposed data into the XML query result. Our key performance focus is the response time for delivering the first results of a query. The most effective of the described decompositions have been implemented in XCacheDB, an XML DBMS built on top of a commercial RDBMS, which serves as our experimental basis. We present experiments and analysis that point to a class of decompositions, called inlined decompositions, that improve query performance for full results and first results, without significant increase in the size of the database.

Management of XML documents without schema in relational database systems

Many applications deal with highly flexible XML documents from different sources, which makes it difficult to define their structure by a fixed schema or a DTD. Therefore, it is necessary to explore ways to cope with such XML documents. The paper analyzes different storage and retrieval methods for schemaless XML documents using the capabilities of relational systems. We compare our experiences with the implementation of an XML-to-relational mapping with an LOB implementation in a commercial RDBMS. The paper concludes with a vision of how different storage methods could converge towards a common high-level XML-API for databases.

Integrating keyword search into XML query processing

Due to the popularity of the XML data format, several query languages for XML have been proposed, specially devised to handle data of which the structure is unknown, loose, or absent. While these languages are rich enough to allow for querying the content and structure of an XML document, a varying or unknown structure can make formulating queries a very difficult task. We propose an extension to XML query languages that enables keyword search at the granularity of XML elements, that helps novice users formulate queries, and also yields new optimization opportunities for the query processor. We present an implementation of this extension on top of a commercial RDBMS; we then discuss implementation choices and performance results.

An expert system approach for database application tuning

The paper describes a method and the principles relative to the tuning of database applications using an expert system. In database applications the maintenance concerns the reorganization of the database, generally decoupled from the software interventions. In our proposal we consider jointly the internal schema of the database and the application programs, i.e. the calls they issue against the underlying DBMS. There are several cases in which it is possible to reformulate a query to have it performed more efficiently by the DBMS. The paper presents first a method that allows to classify transactions on the basis of operations performed on the database, then the optimal internal schema is given for each class of database operations, and finally it is shown how to transform the result of this work in the form of rules for an expert system. The method has been tested using a commercial RDBMS and expert system shell. The application program has been generated artificially in order to have a mix of transactions, difficult to be found in a single application. The results show that performing periodically the database application tuning can improve significantly the performance of the overall application.