In this paper we present a conceptually rather conservative approach to data deduction. Instead of introducing new language constructs we stay within the conventional relational framework, exploit it, however, further by making better use of current language technology. Applying naming, typing and binding to queries and relations leads to a language that gains expressiveness from its orthogonality rather than from extensiveness.

As a framework for our presentation we use DBPL, a strongly typed database programming language based on the relational calculus and on Modula-2. In DBPL, data construction is expressed declaratively through set-oriented expressions which can be abstracted by parameterization and by naming, thus allowing powerful recursive constructor definitions. In the paper, a model-theoretic constructor semantics is defined in two steps: parameter substitution in constructor definitions leads to constructor instances which are then evaluated in a second step. The first step can be regarded as logic program generation, the second step as program evaluation.

We show, that for the general case no procedure exists that evaluates an arbitrary set of parameterized constructors and is guarantied to terminate. However, we are able to classify constructors and give an evaluation algorithm which terminates for interesting subclasses. Finally, we solve an example from the literature showing that np-complete problems can be solved by constructors from a subclass which is decidable. This implies that decidable DBPL constructors are strictly more expressive than stratified Datalog.

The development of database-intensive information systems has to consider a rich set of constraints from many different viewpoints: faithful representation of the application domain, good fit into the usage environment, maintainable conceptual organization of a large software system, cost-saving through reuse of existing experiences, efficient handling of massive data amounts, etc. To unify these viewpoints, we propose to treat them formally as interrelated knowledge bases, and to manage their evolution as a knowledge engineering process. The process is guided by design decisions within the constraints of a formal environment model. Experiences in ESPRIT project DAIDA demonstrate advantages of this approach in terms of conceptual flexibility, process support, and quality assurance.

The activity of software development is moving rapidly from coding of programs to modelling of systems by means of services provided by open and modular environments. This shift enables service suppliers to gain customers by generalizing the functionality of their products, and it allows service consumers to conveniently buy functionality by just specializing their needs. It also motivates consumers to construct applications with more than just the most specialized functionality in mind thus contributing to system extensibility and reusability. Finally, the novel view on software construction blurs the formerly quite sharp distinction between the application part and the system part of software development.

In this paper we apply the consequences of the process sketched above to database systems and data-intensive applications. We argue in favor of a more open but yet controlled interaction between database sytems and their applications and we discuss the implications on the major abstraction principles to be supported by future database programming languages. Finally we follow the open invitation issued by novel computer languages to exploit their potent conceptual basis for the benefit of next generation database application systems.

Bulk structures play a central role in data-intensive application programming. The issues of bulk type definition and implementation as well as their integration into database programming languages are, therefore, key topics in current DBPL research.

In this paper we raise a more general language design and implementation issue by asking whether there should be at all built-in bulk types in DBPLs. Instead, one could argue that bulk types should be realized exclusively as user-definable add-ons to unbiased core languages with appropriate primitives and abstraction facilities.

In searching for an answer we first distinguish two substantially different levels on which bulk types are supported. Elementary Bulk essentially copes with persistent storage of mass data, their identification and update. Advanced Bulk provides additional support required for data-intensive applications such as optimized associative queries and integrity support under concurrency and failure.

Our long-term experience with bulk types in the DBPL language and system clearly shows the limitation of the built-in approach: built-in Advanced Bulk, as elaborate as it may be, frequently does not cover the whole range of demands of a fully-fledged application and often does not provide a decent pay-off for its implementation effort. On the other hand, restriction to built-in Elementary Bulk gives too little user-support for most data-intensive applications.

We report our current work on open database application systems which favours DBPLs with bulk types as add-ons, and outline some of the technological requirements for highly reusable implementations of languages with advanced user-provided bulk type definitions.

The crucial characteristic of object-oriented databases is the concept of object identity which allows the direct representation of various kinds of dependencies between objects, for example, sharing and cyclicity. For object stores to become a viable technology for large shared databases, a certain degree of spatial control over object dependencies (or object locality) seems to be essential. This paper exploits the power of a static type system to capture and evaluate locality information on objects. First, we represent objects by references to complex expressions in a functional language. To control the locality of objects, the space of references is partitioned into a set of subspaces with an explicit reachability constraint. Next, we define a type system where the locality of an object is part of its static type specification and the predefined reachability constraint is enforced via a static typing discipline. We conclude by highlighting the impact of locality information on the operational support to be expected by next generation database systems.

The DBPL language orthogonally integrates sets and first-order predicates into a strongly and statically typed programming language, and the DBPL system supports the language with full database functionality including persistence, query optimization and transaction management. The application of modern language technology to database concepts results in new insights into the relationship between types and schemas, expressions/iterators and queries, selectors and views, or functions and transactions. Furthermore, it allows the exploitation of type theory and formal semantics of programming languages and thus connects database application development with results from program specification and verification.

The DBPL language orthogonally integrates sets and first-order predicates into a strongly and statically typed programming language, and the DBPL system supports the language with full database functionality including persistence, query optimization and transaction management. Modern language technology with its sound naming, typing and binding schemes applied to database concepts results in new insights into the relationship between types and schemas, expressions/iterators and queries, selectors and views, or functions and transactions.