Query Language For Relational Databases Research Articles

The complexity of higher-order queries

Higher-order transformations are ubiquitous within data management. In relational databases, higher-order queries appear in numerous aspects including query rewriting and query specification. This work investigates languages that combine higher-order transformations with ordinary relational database query languages. We study the two most basic computational problems associated with these query languages – the evaluation problem and the containment problem. We isolate the complexity of evaluation at every order, in an analysis similar to that for that standard typed lambda calculus. We show that the containment problem (and hence, the equivalence problem) is decidable in several important subcases, particularly in the case where query constants and variables range over the positive relational operators. The main decidability result relies on techniques that differ from those used in classical query containment. We also show that the analysis of higher-order queries is closely connected to the evaluation and containment problems for non-recursive Datalog.

SQL-based semantics for path expressions over hierarchical data in relational databases

Hierarchical part-of relationships/aggregation structures and related queries are essential parts of information systems. However, relational database query languages do not explicitly support hierarchical relationships and queries. A hierarchical query may require a great number of join operations, which increases the effort in query formulation. Therefore, we propose path expressions in formulating hierarchical views over relational data because path expressions are a conventional and compact way to represent hierarchical relationships. We embed path expressions within SQL queries and compile them to standard SQL. This ensures that the path expressions can straightforwardly be implemented on the top of standard relational database systems. The compilation of a path expression is given by an attribute grammar, a conventional formalism to define the semantics of a language.

Semantic query in a relational database using a local ontology construction

Semantic Web refers to a Web of linked data in which data can be shared and reused, allowing more uses than the traditional 'Web of documents'. However, most of the information on the Web is stored in relational databases and such databases cannot be used by the Semantic Web. Relational databases can, however, be used to construct an ontology as the core of the Semantic Web. We propose a new approach which enables Semantic Web applications to access data actually stored in relational databases using a corresponding ontology. In our approach, domain ontologies can be used to formulate relational database queries in order to simplify the data access of the underlying data sources. The method we propose involves two main phases: the construction of a local ontology from a relational database and a semantic query in a relational database using relational database query language (RDQL). In the first phase, we construct a Web ontology language ontology from data in a relational database. In the second phase, we propose a technique to automatically extract the semantics of relational databases and transform this information into a representation that can be processed and understood by a machine. The method proposed is simulated and implemented using Jena and the simulation results show the effectiveness of the proposed approach. Therefore, we propose RDQL as a real alternative to the commonly used structured query language access to relational databases.

Abstract interpretation of database query languages

In this paper, we extend the Abstract Interpretation framework to the field of query languages for relational databases as a way to support sound approximation techniques. This way, the semantics of query languages can be tuned according to suitable abstractions of the concrete domain of data. The abstraction of relational database system has many interesting applications, in particular, for security purposes, such as fine grained access control, watermarking, etc.

An Infinitary System for the Least Fixed-Point Logic restricted to Finite Models

The notion of the least fixed-point of an operator is widely applied in computer science as, for instance, in the context of query languages for relational databases. Some extensions of first-order classical logic (FOL) with fixed-point operators, as the least fixed-point logic (LFP), were proposed to deal with problems related to the expressivity of FOL. LFP captures the complexity class PTIME over the class of finite ordered structures. The descriptive characterization of computational classes is a central issue within finite model theory (FMT). Trakhtenbrot's theorem states that validity over finite models is not recursively enumerable, that is, completeness fails over finite models. This result is based on an underlying assumption that any deductive system is of finite nature. However, we can relax such assumption as done in the scope of proof theory for arithmetic. Motivated by Gödel incompleteness theorems, proof theory for arithmetic offer an example of a true mathematically meaningful principle non derivable in first-order arithmetic. One way of presenting this proof is based on a definition of a proof system with an infinitary rule, the ω-rule, that establishes the consistency of first-order arithmetic through a proof-theoretical perspective. Inspired by this proof, here we will propose an infinitary natural deduction system for FOL and LFP restricted to finite models, FOLfin and LFPfin, respectively, and we will prove soundness and completeness for them, and also a normalization theorem for fragments of these systems. With this infinitary deductive system for LFPfin, we aim to present a proof theory for a logic traditionally investigated within the scope of FMT. It opens up an alternative way of proving results already obtained within FMT and also new results through a proof theoretical perspective.

Extending a Natural Language Interface with Geospatial Queries

In this installation of architectural perspectives, we describe an extension of a menu-based natural language interface (MBNLI) to support geospatial queries. Our extension makes it easier for application analysts and even inexperienced users to phrase complex queries without knowing the relational database query language SQL, database schemas (table structures), spatial operators, or spatial indexes.

An XML-enabled data mining query language: XML-DMQL

Inspired by the good work of Han et al. (1996) and Elfeky et al. (2001) on the design of data mining query languages for relational and object-oriented databases, in this paper, we develop an expressive XML-enabled data mining query language by extension of XQuery. We first describe some preliminaries on the extension of traditional rule mining to XML mining. The philosophy that guides the language design is then elaborated. We detail the syntax of the mining language and its usage with a number of examples.

The effects of information request ambiguity and construct incongruence on query development

This paper examines the effects of information request ambiguity and construct incongruence on end user's ability to develop SQL queries with an interactive relational database query language. In this experiment, ambiguity in information requests adversely affected accuracy and efficiency. Incongruities among the information request, the query syntax, and the data representation adversely affected accuracy, efficiency, and confidence. The results for ambiguity suggest that organizations might elicit better query development if end users were sensitized to the nature of ambiguities that could arise in their business contexts. End users could translate natural language queries into pseudo-SQL that could be examined for precision before the queries were developed. The results for incongruence suggest that better query development might ensue if semantic distances could be reduced by giving users data representations and database views that maximize construct congruence for the kinds of queries in typical domains.

The processing and improvement of multi-statement queries in Chiql

Chiql is a novel Chinese relational database query language for Chinese users. It supports procedural query style in which users can specify a complex database request in multiple simple statements. This facility renders Chiql simple-to-use and easy-to-remember. However, direct executation of multi-statement Chiql queries (i.e. statement by statement) is often inefficient as potential index-based operations (e.g. join) are by-passed. Furthermore, it often incurs additional database operations, such as scan and projection. To improve this situation, the SMA (Statement Merging Algorithm) is proposed. The goal of SMA is to merge as many dependent statements within a Chiql query as possible to form a more efficient Chiql query. The ability in achieving improved efficiency without sacrificing the simplicity of the language is the major advantage of this algorithm.

Default logic as a query language

Research in nonmonotonic reasoning has focused largely on the idea of representing knowledge about the world via rules that are generally true but can be defeated. Even if relational databases are nowadays the main tool for storing very large sets of data, the approach of using nonmonotonic AI formalisms as relational database query languages has been investigated to a much smaller extent. In this work, we propose a novel application of Reiter's default logic by introducing a default query language (DQL) for finite relational databases, which is based on default rules. The main result of this paper is that DQL is as expressive as SO/sub /spl exist//spl forall// the existential-universal fragment of second-order logic. This result is not only of theoretical importance: We exhibit queries-which are useful in practice-that can be expressed with DQL and cannot with other query languages based on nonmonotonic logics such as DATALOG with negation under the stable model semantics. In particular, we show that DQL is well-suited for diagnostic reasoning.

On periodicity in temporal databases

The issue of periodicity is generally understood to be a desirable property of temporal data that should be supported by temporal database models and their query languages. Nevertheless, there has so far not been any systematic examination of how to incorporate this concept into a temporal DBMS. In this paper we describe two concepts of periodicity, which we call strong periodicity and near periodicity, and discuss how they capture formally two of the intuitive meanings of this term. We formally compare the expressive power of these two concepts, relate them to existing temporal query languages, and show how they can be incorporated into temporal relational database query languages, such as the proposed temporal extension to SQL, in a clean and straightforward manner.

A Single Recursive Predicate Is Sufficient for Pure Datalog

Datalog is a query language for relational databases. The set of predicate symbols in a Datalog program is partioned into EDB (extensional database) and IDB (intensional database) predicates; intuitively, the EDB predicates refer to a stored relational database while the IDB predicates refer to relations to be deduced from the EDB. We show that for each Datalog program there exists a Datalog program having at most one recursive predicate that computes the same IDB extensions. A similar result was obtained by Chandra and Harel. However, they used the built-in predicate ≠. This built-in predicate is not part of the repertoire of pure Datalog and is not used in the construction of this paper.

Database querying and constraint programming

The declarative programming paradigms used in constraint languages can lead to powerful extensions of relational database query languages. This is an overview of recent progress on such constraint query languages, with a list of related open theoretical computer science questions.

An enhanced construction specific SQL

The key to developing a system of information handling in construction that will have a dramatic positive impact on productivity is the development of an appropriate database language. This research involved the development of a standard construction industry specific extension to the Standard Query Language (SQL), the de facto international standard for relational database query languages. Construction Industry-SQL (CI-SOL), is the first industrial extension to SQL and serves as a prototype for a host of other extensions form other industries. CI-SQL uses object data, object attributes, and user-defined extensions to allow rapid access to industry databases. CI-SQL can play a significant role in the way information is retrieved by construction industry, allowing the development of robust databases that support SQL. Ultimately the implementation of CI-SQL will force industry to reconsider the heavy duplication of information that negatively affects productivity and will allow the introduction of keyless data entry and retrieval systems that enhance the speed and accuracy of information handling. Examples in construction material procurement will be used to illustrate the potential for CI-SQL applications. The ultimate use of CI-SQL will be to allow the use of keyless data entry systems, the foremost of which is bar coding, in construction specifications.

A Temporal Query System for Protocol-Directed Decision Support

Chronus is a query system that supports temporal extensions to the Structured Query Language (SQL) for relational databases. Although the relational data model can store time-stamped data and can permit simple temporal-comparison operations, it does not provide either a closed or a sufficient algebra for manipulating temporal data. In this paper, we outline an algebra that maintains a consistent relational representation of temporal data and that allows the type of temporal queries needed for protocol-directed decision support. We also discuss how Chronus can translate between our temporal algebra and the relational algebra used for SQL queries. We have applied our system to the task of screening patients for clinical trials. Our results demonstrate that Chronous can express sufficiently all required temporal queries, and that the search time of such queries is similar to that of standard SQL.

Equivalence of Datalog queries is undecidable

Datalog is a powerful query language for relational databases [10]. We consider the problems of determining containment, equivalence, and satisfiability of Datalog queries. We show that containment and equivalence are recursively unsolvable. This should be contrasted with the work of Aho, Sagiv, and Ullman on relational queries [1]. Satisfiability is easily decidable for Datalog quer ies. We also consider Datalog f which allows function symbols. Here, satisfiability is recursively unsolvable.

Why not SQL!

Abstract The application of traditional database query languages, primarily the Structured Query Language SQL, for geographical information systems (GIS) and other non–standard database applications has been tried unsuccessfully; therefore, several extensions to the relational database query language SQL have been proposed to serve as a spatial query language. It is argued that the SQL framework is inappropriate for an interactive query language for a GIS and an extended SQL is at best a short term solution. Any spatial SQL dialect has a number of serious deficiencies, particularly the patches to incorporate the necessary spatial concepts into SQL.

Database management and design

The use of a central repository for data and a database management system that enables programs to share data more efficiently and ensures the consistency of the data across the system is discussed. Relational databases, which represent both entities and relationships using tables, are described. It is shown that by proper design of the relational tables, the redundancy and wasted space of many ad hoc databases can be eliminated. Data are retrieved from a relational database through the use of a procedural query language. The leading query language for relational databases, the Structured Query Language (SQL), is examined. >

A fuzzy query language for relational databases

A fuzzy query language (FQL) for relational databases is proposed. FQL, constructed as an enhancement of the relational domain calculus, has sufficient capability to represent all four types of the fuzzy statements distinguished by the work of L.A. Zadeh (1978). The idea for constructing FQL is in the formulation of the fuzzy matching degrees that assigns the appropriate values in the interval to any combination of fuzzy queries and tuples in relational databases. FQL helps to provide a human-oriented interface to relational databases that store a vast amount of information. Furthermore, fuzzy expert systems are expected to be provided with the facility to make use of fact data in relational databases through FQL. In addition, FQL is a theoretical basis for systematically developing a higher human-oriented interface with relational databases.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

Hypothetical datalog: complexity and expressibility

We present an extension of Horn-clause logic which can hypothetically add and delete tuples from a database. Such logics have been discussed in the literature, but their complexities and expressibilities have remained an open question. This paper examines two such logics in the function-free, predicate case. It is shown, in particular, that augmenting Horn-clause logic with hypothetical addition increases its data-complexity from PTIME to PSPACE. When deletions are added as well, complexity increases again, to EXPTIME. We then augment the logic with negation-as-failure and develop the notion of stratified hypothetical rulebases. It is shown that negation does not increase complexity. To establish expressibility, we view the logic as a query language for relational databases. It is shown that any typed generic query that is computable in PSPACE can be expressed as a stratified rulebase of hypothetical additions. Similarly, any typed generic query that is computable in EXPTIME can be expressed as a stratified rulebase of hypothetical additions and deletions. Neither of these results assumes the data domain is linearly ordered. In this way, we establish the expressive completeness of our logics for queries in PSPACE and EXPTIME, respectively.