We propose a novel formalism, called Frame Logic (abbr., F-logic), that accounts in a clean and declarative fashion for most of the structural aspects of object-oriented and frame-based languages. These features include object identity, complex objects, inheritance, polymorphic types, query methods, encapsulation, and others. In a sense, F-logic stands in the same relationship to the objectoriented paradigm as classical predicate calculus stands to relational programming. F-logic has a model-theoretic semantics and a sound and complete resolution-based proof theory. A small number of fundamental concepts that come from object-oriented programming have direct representation in F-logic; other, secondary aspects of this paradigm are easily modeled as well. The paper also discusses semantic issues pertaining to programming with a deductive object-oriented language based on a subset of F-logic.

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 dictates 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 theory. 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 welldefined. In looking for limited forms of this operation that always give rise to well-defined operations, we find a number of close ...

We propose a programming paradigm that tries to get close to both the semantic simplicity of relational algebra, and the expressive power of unrestricted programming languages. Its main computational engine is structural recursion on sets. All programming is done within a "nicely" typed lambda calculus, as in Machiavelli [OBB89]. A guiding principle is that how queries are implemented is as important as whether they can be implemented. As in relational algebra, the meaning of any relation transformer is guaranteed to be a total map taking finite relations to finite relations. A naturally restricted class of programs written with structural recursion has precisely the expressive power of the relational algebra. The same programming paradigm scales up, yielding query languages for the complex-object model [AB89]. Beyond that, there are, for example, efficient programs for transitive closure and we are also able to write programs that move out of sets, and then perhaps back to sets, as l...

CORAL is a modular declarative query language/programming language that supports general Horn clauses with complex terms, set-grouping, aggregation, negation, and relations with tuples that contain (universally quantified) variables. Support for persistent relations is provided by using the EXODUS storage manager. A unique feature of CORAL is that it provides a wide range of evaluation strategies and allows users to --- optionally --- tailor execution of a program through high-level annotations. A CORAL program is organized as a collection of modules, and this structure is used as the basis for expressing control choices. CORAL has an interface to C++, and uses the class structure of C++ to provide extensibility. Finally, CORAL supports a command sublanguage, in which statements are evaluated in a user-specified order. The statements can be queries, updates, production-system style rules, or any command that can be typed in at the CORAL system prompt.

The area of deductive databases has matured in recent years, and it now seems appropriate to re ect upon what has been achieved and what the future holds. In this paper, we provide an overview of the area and briefly describe a number of projects that have led to implemented systems.

The LDL system provides a declarative logic-based language and integrates relational database and logic programming technologies so as to support advanced data and knowledge-based applications. This paper contains a comprehensive overview of the system and contains a description of the LDL language and the compilation techniques employed to translate LDL queries into target queries on the stored data. The paper further contains a description of the architecture and runtime environment of the system and the optimization techniques employed in order to improve the performance and assure the safety of the compiled queries. The paper concludes with an account of the experience gained so far with the system, and discusses application areas where the LDL approach appears to be particularly effective.

Glue is a procedural language for deductive databases. It is designed to complement the purely declarative NAIL! language, firstly by performing system functions impossible to write in NAIL!, and secondly by allowing the procedural specification of algorithms for critical code sections. The two languages together are sufficient to write a complete application. Glue was designed to be as close to NAIL! as possible, hence minimizing the impedance mismatch problem. In this paper we concentrate on Glue. Pseudo-higher order programming is used in both languages, in the style of HiLog [1]. In particular Glue-Nail can handle set valued attributes (non1NF schemas) in a clean and efficient manner. NAIL! code is compiled into Glue code, simplifying the system design. An experimental implementation has been written, a more efficient version is under design.

Notallqueries inrelational calculus can beanswered sensibly when disjunction, negation, and universal quantification are allowed, The class of relation calculus queries or formulas that have sensible answers is called the domam independent class which is known to be undecidable. Subsequent research has focused on identifying large decidable subclasses of domain independent formulas. In this paper we investigate the properties of two such classes: the et,aluable formulas and the allowed formulas. Although both classes have been defined before, we give simplified definitions, present short proofs of their main properties, and describe a method to incorporate equality. Although evaluable queries have sensible answers, it is not straightforward to compute them efficiently or correctly, We introduce relational algebra normal form for formulas from which form the correct translation into relational algebra istrivlal. We give algorithms to transform anevaluable formula into an equivalent allowed formula and from there into relational algebra normal form, Our algorithms avoid use of the so-called Dom relation, consisting of all constants appearing in the database or the query. Finally, we describe a restriction under which every domain independent formula is evaluable

Abstract. Deductive databases generalize relational databases by providing sup-port for recursive views and non-atomic data. Aditi is a deductive system based on the client-server model; it is inherently multi-user and capable of exploiting par-allelism on shared-memory multiprocessors. The back-end uses relational tech-nology for efficiency in the management of disk-based data and uses optimization algorithms especially developed for the bottom-up evaluation of logical queries involving recursion. The front-end interacts with the user in a logical language that has more expressive power than relational query languages. We present the structure of Aditi, discuss its components in some detail, and present performance figures.

We present a formal treatment of multisets (that arise when duplicates are not eliminated) and aggregate operators for deductive and relational databases. We define the semantics rigorously and extend the magic-sets technique to programs containing multisets and aggregates. The work presented here is an important step in demonstrating the applicability of the magic-sets technique for optimizing queries in commercial query languages such as SQL. 1 Introduction Previous treatments of Datalog and proposed extensions have treated a program as a collection of definitions of sets of facts (tuples). On the other hand, commercial query languages such as SQL typically support the definition of sets and multisets of tuples, and provide aggregate operators such as SUM and COUNT over sets and multisets. The ability to deal with multisets Part of this work was done at the IBM Almaden Research Center. Work at Stanford was supported by an NSF grant IRI87 -22886, an Air Force grant AFOSR-88-0266...