Database Query Language Research Articles

Δ-languages for sets and LOGSPACE computable graph transformers

We discuss several versions of a set theoretic Δ-language as a reasonable prototype for “nested” database query language where database states and queries are considered, respectively, as hereditarily finite sets and set theoretic operations. In a previous work such a language exactly corresponding to PTIME-computability was introduced. It is supposed that HF-sets are naturally presented by vertices of acyclic graphs. Here we consider a number of languages for Sub PTIME computable set operations via corresponding graph transformers. Two such languages lead to a notion of NLOGSPACE and, respectively, DLOGSPACE computable queries over HF which appear the most natural, at our present knowledge, among others considered here. Unlike the “flat” relational databases the problem of finding sufficiently good corresponding approach for HF proves to be more intricate and, furthermore, gives rise to some interesting questions in finite model theory (cf. Section 13).

A processing framework for object comprehensions

In order to execute database queries efficiently, they are usually translated into an algebra: a small set of operations together with some equivalences. The operations are implemented very efficiently by the database engine, and the equivalences are used to optimise the query. Since query languages for object-oriented databases are more complex than their relational counterparts, the algebra and translation, or processing framework, is more elaborate. This paper describes the processing framework for object comprehensions, a powerful object-oriented query language. Both operations and equivalences of the algebra are defined, together with a translation into it. The framework is illustrated by translating and optimising an example object comprehension query.

Transactions and updates in deductive databases

In this paper, we develop a new approach that provides a smooth integration of extensional updates and declarative query languages for deductive databases. The approach is based on a declarative specification of updates in rule bodies. Updates are not executed as soon as evaluated. Instead, they are collected and then applied to the database when the query evaluation is completed. We call this approach nonimmediate update semantics. We provide a top-down and equivalent bottom-up semantics which reflect the corresponding computation models. We also package set of updates into transactions and we provide a formal semantics for transactions. Then, in order to handle complex transactions, we extend the transaction language with control constructors still preserving formal semantics and semantics equivalence.

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.

Database Query Languages Embedded in the Typed Lambda Calculus

We investigate the expressive power of the typed λ -calculus when expressing computations over finite structures, i.e., databases. We show that the simply typed λ -calculus can express various database query languages such as the relational algebra, fixpoint logic, and the complex object algebra. In our embeddings, inputs and outputs are λ -terms encoding databases, and a program expressing a query is a λ -term which types when applied to an input and reduces to an output. Our embeddings have the additional property that PTIME computable queries are expressible by programs that, when applied to an input, reduce to an output in a PTIME sequence of reduction steps. Under our database input-output conventions, all elementary queries are expressible in the typed λ -calculus and the PTIME queries are expressible in the order-5 (order-4) fragment of the typed λ -calculus (with equality).

On Instance-Completeness for Database Query Languages involving Object Creation

In 1978 Bancilhon and Paredaens introduced a notion of completeness for relational database languages on instance-level. Their criterion was subsequently calledBP-completeness. Since then, it was used frequently in the context of other database models. However, its application in the context of languages involving object creation appears to raise some serious problems. In this paper, we use the graph-oriented object database model GOOD as a framework to propose an alternative formulation of the BP-completeness criterion, adapted to the context of languages involving object creation.

The expressiveness of a family of finite set languages

In this paper we characterize exactly the complexity of a set-based database language called SRL, which presents a unified framework for queries and updates. By imposing simple syntactic restrictions on it, we are able to express exactly the classes, P and LOGSPACE. We also discuss the role of ordering in database query languages and show that the hom operator of Machiavelli language in [Ohori et al. (1989)] does not capture all the order-independent properties.

Unifying data, behaviours, and messages in object-oriented databases

This paper introduces the Knowhow-Bearing Objects (KBO) model. KBO objects have both a data and a behavioural side. This allows us to treat behaviours as objects, so that a database approach can be taken to manage these objects. In particular, we are able to model different kinds of behaviour invocation and to use a database query language to manipulate and query persistent behaviour collections. Examples of complex query construction using an object algebra are given.

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.

On representation and querying incomplete information in databases with bags

We extend the approach to representation of partial information based on orderings on objects from sets to multisets. We characterize orderings arising under closed- and open-world assumptions and analyze their complexity. In contrast to the set case, where orderings are first-order definable and are thus expressible in standard database query languages, the orderings on bags are not expressible in standard bag languages. We give an example of a query on nested relations whose inexpressibility in the extension of relational algebra to nested objects cannot be proved by reduction to the first-order case.

Principles of programming with complex objects and collection types

We present a new principle for the development of database query languages that the primitive operations should be organized around types. Viewing a relational database as consisting of sets of records, this principle dectates that we should investigate separately operations for records and sets. There are two immediate advantages of this approach, which is partly inspired by basic ideas from category theoryl. First, it provides a language for structures in which record and set types may be freely combined: nested relations or complex objects. Second, the fundamental operations for sets are closely related to those for other “collection types” such as bags or lists, and this suggests how database languages may be uniformly extended to these new types. the most general operation on sets, that of structural recursion, is one in which not all programs are well-defined. In looking for limited forms of this operation that always give rise to well-defined operations, we find a number of close connection with exiting database languages, notably those developed for complex objects. Moreover, even though the general paradigm of structural recursion is shown to be no more expressive than one of the existing languages for complex objects, it possesses certain properties of uniformity that make it a better candidate for an efficient, practical language. Thus rather than developing query languages by extending, for example, relational calculus, we advocate a very powerful paradigm in which a number of well-known languages are to be found as natural sublanguages.

Constraint Query Languages

We investigate the relationship between programming with constraints and database query languages. We show that efficient, declarative database programming can be combined with efficient constraint solving. The key intuition is that the generalization of a ground fact, or tuple, is a conjunction of constraints over a small number of variables. We describe the basic constraint query language design principle and illustrate them with four classes of constraints: real polynomial inequalities, dense linear order inequalities, equalities over an infinite domain, and boolean equalities. For the analysis, we use quantifier elimination techniques from logic and the concept of data complexity from database theory. This framework is applicable to managing spatial data and can be combined with existing multidimensional searching algorithms and data structures.

Fast algorithms for universal quantification in large databases

Universal quantification is not supported directly in most database systems despite the fact that it adds significant power to a system's query processing and inference capabilities, in particular for the analysis of many-to-many relationships and of set-valued attributes. One of the main reasons for this omission has been that universal quantification algorithms and their performance have not been explored for large databases. In this article, we describe and compare three known algorithms and one recently proposed algorithm for relational division, the algebra operator that embodies universal quantification. For each algorithm, we investigate the performance effects of explicit duplicate removal and referential integrity enforcement, variants for inputs larger than memory, and parallel execution strategies. Analytical and experimental performance comparisons illustrate the substantial differences among the algorithms. Moreover, comparisons demonstrate that the recently proposed division algorithm evaluates a universal quantification predicate over two relations as fast as hash (semi-) join evaluates an existential quantification predicate over the same relations. Thus, existential and universal quantification can be supported with equal efficiency by adding the recently proposed algorithm to a query evaluation system. A second result of our study is that universal quantification should be expressed directly in a database query language, because most query optimizers do not recognize the rather indirect formulations available in SQL as relational division and therefore produce very poor evaluation plans for many universal quantification queries.

A model management framework for heterogeneous algebraic models: Object-oriented database management systems approach

Recently, a growing number of corporations are adopting diverse algebraic modeling languages (AMLs) to augment their productivity of developing mathematical models. As different AMLs penetrate various sections of an organization, a new challenge is faced: effective management of heterogeneous models that have been designed and developed with different modeling conventions and manipulation operations, but intended to solve similar business problems. In this paper, we propose a model management framework that can accommodate such heterogeneous algebraic models, and in so doing, can provide universal model manipulation commands. Three leading contemporary AMLs, namely, AMPL, GAMS, and SML, are employed to render a representative paradigm. The benefits of this framework are manifold, the more significant among which are the following: (1) providing a conceptual basis for uniformly incorporating dissimilar modeling conventions of different AMLs, the framework adopts the generic model concepts and provides a canonical representation for each model; (2) as the framework embodies the generic model concepts, it consolidates database, modelbase, and associated solvers in a single formalism using an Object-oriented Database Management System (ODBMS); (3) taking advantage of the flexibility of a database query language, the framework can provide uniform model management commands to heterogeneous models represented with different AMLs, and can effectively facilitate integration of the model management system components. Also presented in this paper is a prototype model management system that has been designed following the ideas prescribed by the framework, and developed on a commercial ODBMS, ObjectStore, and using an object-oriented programming language, C++.

Complete problems for fixed-point logics

The notion of logical reducibilities is derived from the idea of interpretations between theories. It was used by Lovász and Gács [LG77] and Immerman [Imm87] to give complete problems for certain complexity classes and hence establish new connections between logical definability and computational complexity.However, the notion is also interesting in a purely logical context. For example, it is helpful to establish nonexpressibility results.We say that a class of τ-structures is a >complete problem for a logic under L-reductions if it is definable in [τ] and if every class definable in can be ”translated” into by L-formulae (cf. §4).We prove the following theorem:1.1. Theorem. There are complete problemsfor partial fixed-point logic andfor inductive fixed-point logic under quantifier-free reductions.The main step of the proof is to establish a new normal form for fixed-point formulae (which might be of some interest itself). To obtain this normal form we use theorems of Abiteboul and Vianu [AV91a] that show the equivalence between the fixed-point logics we consider and certain extensions of the database query language Datalog.In [Dah87] Dahlhaus gave a complete problem for least fixed-point logic. Since least fixed-point logic equals inductive fixed-point logic by a well-known result of Gurevich and Shelah [GS86], this already proves one part of our theorem.However, our class gives a natural description of the fixed-point process of an inductive fixed-point formula and hence sheds some light on completely different aspects of the logic than Dahlhaus's construction, which is strongly based on the features of least fixed-point formulae.

Ordered and Unordered Tree Inclusion

The following tree-matching problem is considered: Given labeled trees $P$ and $T$, can $P$ be obtained from $T$ by deleting nodes? Deleting a node $u$ entails removing all edges incident to $u$ and, if $u$ has a parent $v$, replacing the edge from $v$ to $u$ by edges from $v$ to the children of $u$. The problem is motivated by the study of query languages for structured text databases. Simple solutions to this problem require exponential time. For ordered trees an algorithm is presented that requires $O(|P| |T|)$ time and space. The corresponding problem for unordered trees is also considered and a proof of its NP-completeness is given. An algorithm is presented for the unordered problem. This algorithm works in $O(|P| |T|)$ time if the out-degrees of the nodes in $P$ are bounded by a constant, and in polynomial time if they are $O(\log |T|)$.

Translational semantics for a conceptual level query language

A conceptual level database language for the entity relationship (ER) model implicitly contains integrities basic to ER concepts and special retrieval semantics for inheritances of attributes and relationships. Prolog, which belongs to the logical and physical level, cannot be used as a foundation to directly define the database language. It is shown how Prolog can be enhanced to understand the concepts of entities, relationships, attributes and is-a relationships. The enhanced Prolog is then used as a foundation to define the semantics of a database query language for the ER model. The three basic functions of model specification, updates and retrievals are defined.

Query languages for statistical databases

Statistical database management systems keep raw, elementary and/or aggregated data and include query languages with facilities to calculate various statistics from this data. In this article we examine statistical database query languages with respect to the criteria identified and taxonomy developed in Ozsoyoglu and Ozsoyoglu (1985b). The criteria include statistical metadata and objects, aggregation features and interface to statistical packages. The taxonomy of statistical database query languages classifies them with respect to the data model used, the type of user interface and method of implementation. Temporal databases are rich sources of data for statistical analysis. Aggregation features of temporal query languages, as well as the issues in calculating aggregates from temporal data, are also examined.

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.

An iconic query language for topological relationships in GIS

Abstract The study of query languages for spatial databases is an active research area. This paper describes a new spatial query language that uses a visual grammar to express topological relationships. It is supplemented by text and icons to handle other spatial and non-spatial queries. A graphical user interface is also developed to provide an interactive environment for composing the iconic query command. To test the language, the interface is implemented on a SUN 4 Workstation and linked to Ingres, a relational DBMS. Preliminary tests show that the iconic query language is more convenient for expressing spatial concepts than conventional textual languages. This is due mainly to the two-dimensionality of iconic languages in contrast with the linear nature of conventional languages.