Relational Query Languages Research Articles

An approximate user-complexity measure for relational query language systems

Complexity theory provides a powerful methodology for evaluating the time and space requirements of algorithms. It would be helpful if a similar theory could be developed to analyze the level of difficulty presented to the user by database query languages. The relational database languages are of particular interest. Their power and flexibility have real potential for supporting the decision making needs of managers. In this paper an approximate user complexity measure is formulated and applied to three different experiments. These experiments measure user performance in the following tests: (1) relational algebra versus tuple calculus, (2) relational algebra versus domain calculus, and (3) relational algebra versus functional algebra. The results favor the procedural relational languages, and the approximate complexity measure constructed here parallels user performance.

A functional programming-directed database machine

This paper proposes as a database machine a system whose main computational engine is an FFP machine. The FFP machine is a small-grain, cellular tree computer with massive parallelism, which directly executes FFP languages. We describe a method to naturally embed relational query languages such as sql into FFP languages. We present FFP programs for some relational query operations (selection, projection, and join), and we show that they are executed efficiently by taking advantage of the massive parallelism accommodated by the FFP machine. Input/output architectures with varying degrees of parallelism are examined, and corresponding algorithms presented. Because the proposed system is also able to perform efficiently numeric and symbolic processing, it is appropriate for computation-intensive database applications such as expert database systems and engineering database systems.

A NEW RELATIONAL (DOMAIN-CALCULUS TYPE) QUERY LANGUAGE BASED ON THE PARTITION MODEL

Coming from the concept of “interpretation of a value of an attribute” as it appears in Spyratos (1985), the basis for a nonprocedural relational query language is stated in this article. The syntax proposed by Reiter (1984) is (if some minimal modifications are done) a suitable one for expressing queries in this language.

A note on the translation of SQL to tuple calculus

This note presents a translation of a subset of the relational query language SQL into the well known tuple calculus. Roughly speaking, tuple calculus corresponds to first order predicate calculus. The SQL subset is relationally complete and represents a “relational core” of the language. Nevertheless, our translation is simple and elegant. Therefore it is especially well suited as a beginners course into the principles of a formal definition of SQL.

An extension of SQL for querying graph relations

Relational query languages miss some of the expressive power required for knowledgebase applications. Analyzing a collection of examples we argue for supporting various types of queries on graph relations. Thus we define a graph manipulation kernel as an extension of SQL. It has features to generate a basic set of paths (in a directed graph), to select the relevant paths from it by some conditions (including those referring again to a pathset) and to produce the desired output. The implementation is based on page access minimizing adaptions of graph algorithms.

SQL extensions for security assertions

We describe the extensions to the relational query language SQL that are necessary to support multilevel security in database management systems. In a multilevel secure database with data at a variety of sensitivity levels. The data classifications are provided by security assertions. Consequently, the data definition language and the data manipulation language should provide support for incorporating these assertions.

On accessing object-oriented databases: expressive power, complexity, and restrictions

A formal framework for studying the expressive power and complexity of OODB queries is developed. Three approaches to modeling sets are articulated and compared. The class of regular OODB schemas supports the explicit representation of set-valued types. Using an object-based semantics for sets, the regular schemas correspond to most implemented OODB systems in the literature; a value-based semantics for sets is also introduced. Without restrictions, both of these approaches support the specification of all computable queries. Assuming that the new operator is prohibited, the query language of the regular OODB schemas under the object-based semantics is complete in PSPACE; and under the value-based semantics it has hyper-exponential complexity. The third approach to modeling sets is given by the algebraic OODB model, in which multi-valued attributes rather than set-valued types are supported. method implementations can use operators stemming from the relational algebra, and do not have side-effects. The query language of algebraic OODBs is more powerful than the relational algebra but has complexity bounded by PTIME. The expressive power and complexity of data access for other variations of OODBs are also considered. Finally, a new relational query language, called algebra + pointwise recursion , is introduced. This is equivalent to the algebraic OODB language, and can compute generalized transitive closure.

An improved division operator for relational algebra

Since the introduction of the relational data model, relational algebra has been used to gauge the completeness of relational query languages. As a concise language for formulating queries against relational databases, relational algebra is unmatched. Furthermore, human factor studies have shown that for difficult queries, users perform better using the procedurally-oriented relational algebra than using a non-procedural, specification-based, language such as SQL. Still, the current implementations of relational algebra in database management systems are not “friendly” when it comes to formulation of queries involving universal quantification. The algebraic operation of division normally used for this purpose is difficult for most users to comprehend and work with and is incapable of expressing queries that demand the comparison of sets of values associated with matching groups of tuples in two relations. This paper introduces a new algebraic operation, called grouped generalized division (GGD), which overcomes such shortcomings. We also show how the GGD operation can be expressed in terms of the other more “primitive” algebraic operations. As such, the implementors of algebraic languages can support the GGD operation at the user interface with minimal effort.

Nurql: A nested universal relation query language

The universal relation (UR) model aims to free the user from logical navigation in a relational database. A UR query language simplifies user queries since the database is queried solely through the attributes. Furthermore, the nested relational model extends the applicability of the relational model to non-business applications, and a nested relational query language provides a powerful and flexible user interface. Under the nested UR model, introduced by the authors, nested relations constitute the internal level for the nested UR scheme at the conceptual level, and a UR interface constitutes a view at the external level. Herein we describe NURQL (Nested UR Query Language), which is the query language proposed for the nested UR model, and show that NURQL combines the simplicity of a UR query language with the power of a nested relational query language.

Relational theory of queries

In this paper a new presentation of the relational theory of queries will be given. Both the relational algebra and the (domain) relational calculus will be systematically derived from first-order logic. The connections between logic, algebra and calculus will become extremely simple: e.g. the relational algebra will be isomorphic with a subset of relational calculus. Also some theoretical results about the completeness of the relational query languages will be presented. Both the relational calculus and the relational algebra will be extended to contain aggregate functions.

A homogeneous relational model and query languages for temporal databases

In a temporal database, time values are associated with data item to indicate their periods of validity. We propose a model for temporal databases within the framework of the classical database theory. Our model is realized as a temporal parameterization of static relations. We do not impose any restrictions upon the schemes of temporal relations. The classical concepts of normal forms and dependencies are easily extended to our model, allowing a suitable design for a database scheme. We present a relational algebra and a tuple calculus for our model and prove their equivalence. Our data model is homogeneous in the sense that the periods of validity of all the attributes in a given tuple of a temporal relation are identical. We discuss how to relax the homogeneity requirement to extend the application domain of our approach.

Requirements for coupling small scale DBMSs in a distributed office environment

The typical requirements for coupling diverse relational database management systems residing at personal workstations are examined, and a concise system architecture dealing with the issues of a distributed office environment is proposed. Effective interconnection of the individual database management systems is achieved through uniform, integrated access to the different databases in the network. Furthermore, the use of a relational query language simple enough for office workers and yet sufficiently powerful to handle the intricacies of a distributed office environment is suggested. The system envisaged here is oriented toward databases requiring moderate resources; personal or small group databases in an office environment are likely to benefit most from the proposed approach.

PICASSO: A graphical query language

AbstractPICASSO (PICture Aided Sophisticated Sketch Of database queries) is a graphics‐based database query language designed for use with a universal relation database system. The primary objective of PICASSO is ease of use. Graphics are used to provide a simple method of expressing queries and to provide visual feedback to the user about the system's interpretation of the query. Inexperienced users can use the graphical feedback to aid them in formulating queries whereas experienced users can ignore the feedback. Inexperienced users can pose queries without knowing the details of underlying database schema and without learning the formal syntax of SQL‐like query language. This paper presents the syntax of PICASSO queries and compares PICASSO queries with similar queries in standard relational query languages. Comparisons are also made with System/U, a non‐graphical universal relation system on which PICASSO is based. The hypergraph semantics of the universal relation are used as the foundation for PICASSO and their integration with a graphical workstation enhances the usability of database systems.

A graphical query language supporting recursion

We define a language G for querying data represented as a labeled graph G . By considering G as a relation, this graphical query language can be viewed as a relational query language, and its expressive power can be compared to that of other relational query languages. We do not propose G as an alternative to general purpose relational query languages, but rather as a complementary language in which recursive queries are simple to formulate. The user is aided in this formulation by means of a graphical interface. The provision of regular expressions in G allows recursive queries more general than transitive closure to be posed, although the language is not as powerful as those based on function-free Horn clauses. However, we hope to be able to exploit well-known graph algorithms in evaluating recursive queries efficiently, a topic which has received widespread attention recently.

A study of transitive closure as a recursion mechanism

We show that every linearly recursive query can be expressed as a transitive closure possibly preceded and followed by operations already available in relational algebra. This reduction is possible even if there are repeated variables in the recursive literals and if some of the arguments in the recursive literals are constants. Such an equivalence has significant theoretical and practical ramifications. One the one hand it influences the design of expressive notations to capture recursion as an augmentation of relational query languages. On the other hand implementation of deductive databases is impacted in that the design does not have to provide the generality that linear recursion would demand. It suffices to study the single problem of transitive closure and to provide an efficient implementation for it.

Extending relational algebra and relational calculus with set-valued attributes and aggregate functions

In commercial network database management systems, set-valued fields and aggregate functions are commonly supported. However, the relational database model, as defined by Codd, does not include set-valued attributes or aggregate functions. Recently, Klug extended the relational model by incorporating aggregate functions and by defining relational algebra and calculus languages. In this paper, relational algebra and relational calculus database query languages (as defined by Klug) are extended to manipulate set-valued attributes and to utilize aggregate functions. The expressive power of the extended languages is shown to be equivalent. We extend the relational algebra with three new operators, namely, pack, unpack, and aggregation-by-template. The extended languages form a theoretical framework for statistical database query languages.

Montage: a system for three-dimensional reconstruction by personal computer

This paper describes a simplified system for serial section three-dimensional (3-D) reconstruction. A set of 9 software programs runs on a standard personal computer and produces camera-ready illustrations suitable for publication. The user enters trace points on a digitizing tablet from sections that have been already aligned. A 3-D view of the reconstructed object is generated which can be displayed with hidden lines removed. Analysis of volume, surface area and autoradiographic grain density are performed automatically. A relational database query language allows display and analysis of a selected subset of the data. The system runs under the UNIX operating system which allows the programs to be easily transported to new hardware or modified for other purposes.

Extending a database system with procedures

This paper suggests that more powerful database systems (DBMS) can be built by supporting database procedures as full-fledged database objects. In particular, allowing fields of a database to be a collection of queries in the query language of the system is shown to allow the natural expression of complex data relationships. Moreover, many of the features present in object-oriented systems and semantic data models can be supported by this facility. In order to implement this construct, extensions to a typical relational query language must be made, and considerable work on the execution engine of the underlying DBMS must be accomplished. This paper reports on the extensions for one particular query language and data manager and then gives performance figures for a prototype implementation. Even though the performance of the prototype is competitive with that of a conventional system, suggestions for improvement are presented.

SQL/NF: A query language for ¬1NF relational databases

There is growing interest in abandoning the first-normal-form assumption on which the relational database model is based. This interest has developed from a desire to extend the applicability of the relational model beyond traditional data-processing application. In this paper, we extend one of the most widely used relational query languages, SQL, to operate on non-first-normal-form relations. In this framework, well allow attributes to be relation-valued as well as atomic-valued (e.g. integer or character). A relation which occurs as the value of an attribute in a tuple of another relation is said to be nested. Our extended language, called SQL/NF, includes all of the power of standard SQL as well as the ability to define nested relations in the data definition language and query these relations directly in the extended data manipulation language. A variety of improvements are made to SQL; the syntax is simplified and useless constructs and arbitrary restrictions are removed.

PIQUE: A relational query language without relations

Relational database systems have gone far towards providing users with physical data independence. To use a relational database, users need not know the physical storage structures of relations, and are protected from changes in these structures. However, a user must still navigate among relations. In other words, if the information needed to answer a question spans several relations, he must explicitly specify how these relations are to be combined. Physical data independence is not enough. A user should also be afforded some degree of structural data independence. More specifically, he should be able to pose queries without having to explicitly navigate among relations in the database. Instead, the system should do the navigation for him. We consider universal scheme interfaces as a means for automatic database navigation, and introduce the concept of a generator as central to such navigation. We describe a particular generator based on the semantic notions of reducible and irreducible facts, and present PIQUE, an attribute-based query language designed to work with this generator. PIQUE is a concise, yet powerful, language with natural semantics. A distinguishing feature of PIQUE is that tuple variables in queries are bound implicitly and that the logical connectives “and”, “or,” and “not” can affect the binding, and, therefore, take on “semantic overtones.” Furthermore, the semantic interpretation PIQUE gives to these connectives is more natural than the one given by most other query languages. In the Appendix, we present PIQUE's formal syntax and semantics, along with the proof that PIQUE is relationally complete.