Arbitrary Database Research Articles

Tunable Tradeoff between Quantum and Classical Computation via Nonunitary Zeno-like Dynamics

We propose and analyze a nonunitary variant of the continuous time Grover search algorithm based on frequent Zeno-type measurements. We show that the algorithm scales similarly to the pure quantum version by deriving tight analytical lower bounds on its efficiency for arbitrary database sizes and measurement parameters. We also study the behavior of the algorithm subject to noise, and find that under certain oracle and operational errors our measurement-based algorithm outperforms the standard algorithm, showing robustness against these noises. Our analysis is based on deriving a non-hermitian effective description of the algorithm, which yields a deeper insight into components responsible for the quantum and the classical operation of the protocol.

Ontology-aware dynamically adaptable free-form natural language agent interface for querying databases

Studying the literature, one can see a large number of systems that provide natural language interfaces to databases. Despite their importance, these interfaces address only one part of the problem: transforming natural language queries to SQL queries and perhaps executing them against the underlying database. To truly handle the problem, it should be possible to develop dynamically adaptable database interfaces that can (1) adjust their functional behavior on the fly using only domain knowledge and (2) dynamically bind themselves to arbitrary databases and interface with them with no (or very little) human intervention. In particular, the interfaces should have a fixed process (algorithms and codes) and rely only on domain knowledge for adapting their functionality to any arbitrary database. This paper addresses this problem by offering a free-form natural language interface agent that, given domain ontologies, can bind itself to a target database and provide a natural language interface to it. The agent system uses its ontologies to establish mappings on-the-fly between a specific domain ontology and the underlying database’s metadata, and then to transform free-form natural language queries to formal SQL queries that can execute against the underlying database. The preliminary simulations using our proof-of-concept prototype showed that our system successfully attached itself to databases and achieved high recall and precision in transforming natural language queries to formal ones.

Global Property Prediction: A Benchmark Study on Open-Source, Perovskite-like Datasets.

Screening combinatorial space for novel materials, such as perovskite-like ones for photovoltaics, has resulted in a high amount of simulated high-throughput data and analysis thereof. This study proposes a comprehensive comparison of structural fingerprint-based machine learning models on seven open-source databases of perovskite-like materials to predict band gaps and energies. It shows that none of the given methods, including graph neural networks, are able to capture arbitrary databases evenly, while underlining that commonly used metrics are highly database-dependent in typical workflows. In addition, the applicability of variance selection and autoencoders to significantly reduce fingerprint size indicates that models built with common fingerprints only rely on a submanifold of the available fingerprint space.

Enabling efficient process mining on large data sets: realizing an in-database process mining operator

Process mining can be used to analyze business processes based on logs of their execution. These execution logs are often obtained by querying a database and storing the results in a file. The mining itself is then done on the file, such that the data processing power of the database cannot be used after the log is extracted. Enabling process mining directly on a database therefore provides additional flexibility and efficiency. To help facilitate this, this paper formally defines a database operator that extracts the ‘directly follows’ relation—one of the relations that is at the heart of process mining—from an operational database. It defines the operator using the well-known relational algebra and formally proves equivalence properties of the operator that are useful for query optimization. Subsequently, it presents time-complexity properties of the operator. Finally, it presents an implementation of the operator as part of the H2 DBMS and demonstrates that this implementation extracts the ‘directly follows’ relation from a database with an arbitrary database structure within a fraction of a second; several orders of magnitude faster than is currently possible.

Finite-State Map-Reduce Computation and Relational Algebra Queries

We introduce three formal models of distributed systems for query evaluation on massive databases: Distributed Streaming with Register Automata (DSAs), Distributed Streaming with Register Transducers (DSTs), and Distributed Streaming with Register Transducers and Joins (DSTJs). These models are based on the map-reduce paradigm where the input is transformed into a dataset of key-value pairs, and on each key a local computation is performed on the values associated with that key resulting in another set of key-value pairs. Computation proceeds in a constant number of rounds, where the result of the last round is the input to the next round, and transformation of key-value pairs is required to be generic. The difference between the three models is in the local computation part. In DSAs it is limited to making one pass over its input using a register automaton, while in DSTs it can make two passes: in the first pass it uses a finite state automaton and in the second it uses a register transducer. The third model DSTJs is an extension of DSTs, where local computations are capable of constructing the Cartesian product of two sets. We obtain the following results: (1) DSAs can evaluate first-order queries over bounded degree databases; (2) DSTs can evaluate semijoin algebra queries over arbitrary databases; (3) DSTJs can evaluate the whole relational algebra over arbitrary databases; (4) DSTJs are strictly stronger than DSTs, which in turn are strictly stronger than DSAs; (5) within DSAs, DSTs, and DSTJs, there is a strict hierarchy w.r.t. the number of rounds.

An Exact Quantum Search Algorithm with Arbitrary Database

In standard Grover’s algorithm for quantum searching, the probability of finding a marked state is not exactly 1, and some modified versions of Grover’s algorithm that search a marked state from an evenly distributed database with full successful rate have been presented. In this article, we present a generalized quantum search algorithm that searches M marked states from an arbitrary distributed N-item quantum database with a zero theoretical failure rate, where N is not necessary to be the power of 2. We analyze the general properties of our search algorithm, we find that our algorithm has periodicity with a period of 2J + 1, and it is effective with certainty for J + (2J + 1)m times of iteration, where m is an arbitrary nonnegative number.

Flexible and extensible preference evaluation in database systems

Personalized database systems give users answers tailored to their personal preferences. While numerous preference evaluation methods for databases have been proposed (e.g., skyline, top-k, k-dominance, k-frequency), the implementation of these methods at the core of a database system is a double-edged sword. Core implementation provides efficient query processing for arbitrary database queries, however, this approach is not practical since each existing (and future) preference method requires implementation within the database engine. To solve this problem, this article introduces FlexPref, a framework for extensible preference evaluation in database systems. FlexPref, implemented in the query processor, aims to support a wide array of preference evaluation methods in a single extensible code base. Integration with FlexPref is simple, involving the registration of only three functions that capture the essence of the preference method. Once integrated, the preference method “lives” at the core of the database, enabling the efficient execution of preference queries involving common database operations. This article also provides a query optimization framework for FlexPref, as well as a theoretical framework that defines the properties a preference method must exhibit to be implemented in FlexPref. To demonstrate the extensibility of FlexPref, this article also provides case studies detailing the implementation of seven state-of-the-art preference evaluation methods within FlexPref. We also experimentally study the strengths and weaknesses of an implementation of FlexPref in PostgreSQL over a range of single-table and multitable preference queries.

Flexible and extensible preference evaluation in database systems

Personalized database systems give users answers tailored to their personal preferences. While numerous preference evaluation methods for databases have been proposed (e.g., skyline, top-k, k-dominance, k-frequency), the implementation of these methods at the core of a database system is a double-edged sword. Core implementation provides efficient query processing for arbitrary database queries, however, this approach is not practical since each existing (and future) preference method requires implementation within the database engine. To solve this problem, this article introduces FlexPref, a framework for extensible preference evaluation in database systems. FlexPref, implemented in the query processor, aims to support a wide array of preference evaluation methods in a single extensible code base. Integration with FlexPref is simple, involving the registration of only three functions that capture the essence of the preference method. Once integrated, the preference method “lives” at the core of the database, enabling the efficient execution of preference queries involving common database operations. This article also provides a query optimization framework for FlexPref, as well as a theoretical framework that defines the properties a preference method must exhibit to be implemented in FlexPref. To demonstrate the extensibility of FlexPref, this article also provides case studies detailing the implementation of seven state-of-the-art preference evaluation methods within FlexPref. We also experimentally study the strengths and weaknesses of an implementation of FlexPref in PostgreSQL over a range of single-table and multitable preference queries.

A quantum algorithm that deletes marked states from an arbitrary database

We present a general quantum deletion algorithm that deletes M marked states from an N-item quantum database with arbitrary initial distribution. The general behavior of this algorithm is analyzed, and analytic result is given. When the number of marked states is no more than \(\tfrac{{3N}} {4}\), this algorithm requires just a single query, and this achieves exponential speedup over classical algorithm.

A natural language interface plug-in for cooperative query answering in biological databases

BackgroundOne of the many unique features of biological databases is that the mere existence of a ground data item is not always a precondition for a query response. It may be argued that from a biologist's standpoint, queries are not always best posed using a structured language. By this we mean that approximate and flexible responses to natural language like queries are well suited for this domain. This is partly due to biologists' tendency to seek simpler interfaces and partly due to the fact that questions in biology involve high level concepts that are open to interpretations computed using sophisticated tools. In such highly interpretive environments, rigidly structured databases do not always perform well. In this paper, our goal is to propose a semantic correspondence plug-in to aid natural language query processing over arbitrary biological database schema with an aim to providing cooperative responses to queries tailored to users' interpretations.ResultsNatural language interfaces for databases are generally effective when they are tuned to the underlying database schema and its semantics. Therefore, changes in database schema become impossible to support, or a substantial reorganization cost must be absorbed to reflect any change. We leverage developments in natural language parsing, rule languages and ontologies, and data integration technologies to assemble a prototype query processor that is able to transform a natural language query into a semantically equivalent structured query over the database. We allow knowledge rules and their frequent modifications as part of the underlying database schema. The approach we adopt in our plug-in overcomes some of the serious limitations of many contemporary natural language interfaces, including support for schema modifications and independence from underlying database schema.ConclusionsThe plug-in introduced in this paper is generic and facilitates connecting user selected natural language interfaces to arbitrary databases using a semantic description of the intended application. We demonstrate the feasibility of our approach with a practical example.

Efficient core computation in data exchange

Data exchange deals with inserting data from one database into another database having a different schema. Fagin et al. [2005] have shown that among the universal solutions of a solvable data exchange problem, there exists—up to isomorphism—a unique most compact one, “the core”, and have convincingly argued that this core should be the database to be materialized. They stated as an important open problem whether the core can be computed in polynomial time in the general setting where the mapping between the source and target schemas is given by source-to-target constraints that are arbitrary tuple generating dependencies (tgds) and target constraints consisting of equality generating dependencies (egds) and a weakly acyclic set of tgds. In this article, we solve this problem by developing new methods for efficiently computing the core of a universal solution. This positive result shows that data exchange based on cores is feasible and applicable in a very general setting. In addition to our main result, we use the method of hypertree decompositions to derive new algorithms and upper bounds for query containment checking and computing cores of arbitrary database instances. We also show that computing the core of a data exchange problem is fixed-parameter intractable with respect to a number of relevant parameters, and that computing cores is NP-complete if the rule bodies of target tgds are augmented by a special predicate that distinguishes a null value from a constant data value.

Guest Editors' Introduction: Special Section on Software Engineering for Secure Systems

THE proliferation of computers in society has meant that organizational and personal assets are increasingly stored and manipulated by software systems. The scale of misuse of these assets has also increased because of their worldwide accessibility through the Internet and the automation of systems. Security is concerned with the prevention of such misuse. While no system can be made completely secure, understanding the context in which a system will be deployed and used, the risks and threats of its misuse, and the systematic development of its software are increasingly recognized as critical to its success. The cross-fertilization of systems development techniques from software engineering and security engineering offers opportunities to minimize duplication of research efforts in both areas and, more importantly, to bridge gaps in our knowledge of how to develop secure softwareintensive systems. The aim of this special issue is to publish novel research work that draws upon software engineering to develop secure systems more effectively. Its scope covers the processes, techniques, technology, people, and knowledge bases that have, or need, the capability to contribute to producing more secure software-intensive systems. In response to the call for papers for this special section, we received 41 submissions, regarding software engineering issues addressing the requirements, design, coding, testing, and maintenance of secure software systems. Each paper was reviewed by at least three expert referees. After two rounds of reviewing, we selected six papers which focus on requirements and design of secure software. The first two papers address both security and privacy requirements, making use of varying degrees of formalism to represent and analyze those requirements. “Analyzing Regulatory Rules for Privacy and Security Requirements” by Travis Breaux and Annie Anton addresses the often overwhelming complexity of regulatory requirements of financial, healthcare, and other software. The formalism and process presented glean enforceable security policy directly from the regulatory statutes. “Privately Finding Specifications” by Westley Weimer and Nina Mishra deals with one of the daunting realities of data sharing, the fact that it is often an all or nothing proposition. This paper describes an attempt to mitigate oversharing in the discovery of software specifications by perturbing program traces. The careful addition of noise into the traces allows specification discovery while preventing the exposure of other sensitive aspects of the program. The next three papers consider how the design of software systems can be realized through security infrastructure. “Semantics-Based Design for Secure Web Services” by Massimo Bartoletti, Pierpaolo Degano, Gian Luigi Ferrari, and Roberto Zunino considers how to develop secure Web services by formally reasoning about policy compliance over historical behaviors. In essence, Web services “contract” (compose) with those systems that respect policies of interest, thereby ensuring globally secure behavior. “Provable Protection against Web Application Vulnerabilities Related to Session Data Dependencies” by Lieven Desmet, Pierre Verbaeten, Wouter Joosen, and Frank Piessens acknowledge recent advances in secure Web application design and development that have made online systems safer. The techniques detailed in this paper prevent misuse of often loosely coupled session dependencies in and among Web applications. “WASP: Protecting Web Applications Using Positive Tainting and Syntax-Aware Evaluation” by William Halfond, Alessandro Orso, and Panagiotis Manolios presents a novel method for preventing SQL injection attacks—attacks in which the adversary inserts arbitrary database query code into an application by manipulating input strings. The paper uses language techniques to dynamically annotate ”trusted” strings, thereby avoiding any use of potentially unsafe strings. The final paper presents a method of certifying that a software system meets its security requirements. “Applying Formal Methods to a Certifiably Secure Software System” by Connie Heitmeyer, Myla Archer, Elizabeth Leonard, and John McLean adds to recent advances that are beginning to make this costly and complex process of formal verification tractable. This paper presents a novel certification method that uses formalized security models to construct a mechanized proof of security over a real-world target system. The papers in this special section demonstrate the strength of research in the area of engineering secure software. If the range and strength of the submissions to the special section are anything to go by, the area is healthy and vibrant and we fully expect many of the submissions that IEEE TRANSACTIONS ON SOFTWARE ENGINEERING, VOL. 34, NO. 1, JANUARY/FEBRUARY 2008 3

An Ehrenfeucht-Fraïssé game approach to collapse results in database theory

Pursuing an Ehrenfeucht-Fraïssé game approach to collapse results in database theory, we show that, in principle, every natural generic collapse result may be proved via a translation of winning strategies for the duplicator in an Ehrenfeucht-Fraïssé game. Following this approach we can deal with certain infinite databases where previous, highly involved methods fail. We prove the natural generic collapse for Z -embeddable databases over any linearly ordered context structure with arbitrary monadic predicates, and for N -embeddable databases over the context structure 〈 R , < , + , Mon Q , Groups 〉 , where Groups is the collection of all subgroups of 〈 R , + 〉 that contain the set of integers and Mon Q is the collection of all subsets of a particular infinite set Q of natural numbers. This, in particular, implies the collapse for arbitrary databases over 〈 N , < , + , Mon Q 〉 and for N -embeddable databases over 〈 R , < , + , Z , Q 〉 . That is, first-order logic with < can express the same order-generic queries as first-order logic with <, +, etc. Restricting the complexity of the formulas that may be used to formulate queries to Boolean combinations of purely existential first-order formulas, we even obtain the collapse for N -embeddable databases over any linearly ordered context structure with arbitrary predicates. Finally, we develop the notion of N -representable databases, which is a natural generalisation of the notion of finitely representable databases. We show that natural generic collapse results for N -embeddable databases can be lifted to the larger class of N -representable databases. To obtain, in particular, the collapse result for 〈 N , < , + , Mon Q 〉 , we explicitly construct a winning strategy for the duplicator in the presence of the built-in addition relation +. This, as a side product, also leads to an Ehrenfeucht-Fraïssé game proof of the theorem of Ginsburg and Spanier, stating that the spectra of FO (<,+)-sentences are semi-linear.

Deciding implication for functional dependencies in complex-value databases

Modern applications increasingly require the storage of data beyond relational structure. The challenge of providing well-founded data models that can handle complex objects such as lists, sets, multisets, unions and references has not been met yet in a completely satisfactory way. The success of such data models will greatly depend on the existence of automated database design techniques that generalise achievements from relational databases. In this paper, we study the implication problem of functional dependencies (FDs) in the presence of records, sets, multisets and lists. Database schemata are defined as nested attributes, database instances as nested relations and FDs are defined in terms of subattributes of the database schema. The expressiveness of FDs deviates fundamentally from previous approaches in different data models including the nested relational data model and XML. The implication problem is to decide whether for an arbitrary database schema, and an arbitrary set Σ ∪ { σ } of FDs defined on that schema, every database instance that satisfies all FDs in Σ also satisfies σ . The difficulty in generalising the solution from the relational data model to the presence of sets and multisets is caused by the fact that the value on the join of subattributes is no longer determined by the values on the subattributes. Based on the notion of a unit, we propose to decompose the database schema in such a way that the closure of a set of nested attributes can be computed on the components of the schema. The implementation of the algorithm is based on a representation theorem for Brouwerian algebras. The main contribution is the proof that the algorithm works correctly and in polynomial-time in the size of the input. Defining the size of the input is not trivial since the measure should both generalise the one that is used for relational databases and do justice to the presence of sets and multisets. Our solution to the implication problem allows to solve other important problems that occur in database design. We present polynomial-time algorithms to determine non-redundant covers of sets of FDs, and to decide whether a given set of subattributes forms a superkey.

A generic content-management tool for Web databases

WebCUS uses XML and XSL to generate Web-based update interfaces with integrated access control mechanisms for arbitrary database schemas. WebCUS's adaptability allowed us to reduce development time and costs in building update interfaces for managing the content databases of the 2002 Vienna International Festival (VIF) and the Austrian Academy of Sciences (AAS) Web sites. We examine the WebCUS architecture and describe our experiences deploying the system with the VEF and AAS sites.

The Starburst active database rule system

The paper describes the development of the Starburst Rule System, an active database rules facility integrated into the Starburst extensible relational database system at the IBM Almaden Research Center. The Starburst rule language is based on arbitrary database state transitions rather than tuple or statement level changes, yielding a clear and flexible execution semantics. The rule system has been implemented completely. Its rapid implementation was facilitated by the extensibility features of Starburst, and rule management and rule processing are integrated into all aspects of database processing.

How to modify SQL queries in order to guarantee sure answers

Some problems connected with the handling of null values in SQL are discussed. A definition of sure answers to SQL queries is proposed which takes care of the “no information” meaning of null values in SQL. An algorithm is presented for modifying SQL queries such that answers are not changed for databases without null values but sure answers are obtained for arbitrary databases with standard SQL semantics.

Method for integrating a knowledge-based system with an arbitrary database system

This article describes two important contemporary phenomenons – the crisis of masculinity and the economic crisis. In general they are treated as the independent parts of life. In the analysis below the economic sphere was taken into consideration as a part of stereotype about masculinity. The idea of article is based on the statistics made by Eurostat. Important part of the article consists also of the scientific theories and articles connected with economy or gender problems. The aim of the research was to find some connotations between the crisis of masculinity and economic crisis – especially in 2 points: the rate of unemployment and the rate of marriages. The data comes from the surveys made in years 2004-2011 – 3 years before the Global Financial Crisis and 3 years after it had started. In the text below the emphasis is putted more on the effects of analysis than on analysis itself.

Join dependencies in relational-database design

Problems of logical scheme design for relational database systems are considered when the integrity constraints specifying an application area are join dependencies (JD). The admissibility of an arbitrary database scheme is defined in terms of the existence of some JD. The problem of generating various admissible schemes is reduced to the inference problem for JD. A system of inference rules is presented to deduce JD logically implied by a given set of JD. To estimate the influence of a scheme on query evaluation, the problem of finding a minimum subset of database relations ensuring the correct answer is investigated. A polynomial algorithm is developed for finding a minimum set of database relations whose join provides the same answer to a given query as the join of the whole database (assuming all database relations to be projections of a single relation).

An optimal access path handling strategy in a database environment

This paper presents an efficient access path storage and manipulation facility in a relational database management system. It includes an access path storage structure and an artificial intelligence which enables the DBMS to generate, store, and maintain paths which are more likely to be needed by random query requests. A model is developed for simulation, and several path delete strategies are simulated. Path delete strategies aiming for least recently used and least frequently used access paths are shown to require minimal DBA interference and to result in lowest average query processing cost. The proposed path handling strategy is sufficiently general to permit application in an arbitrary database system.