An earlier paper by Jajodia and Kogan [5] introduced an approach for building multilevel secure object-oriented database systems based on a secure message filtering mechanism. Under this approach each object has a unique security level and, therefore, multilevel objects are not supported. In the present paper, we discuss an approach, based on composite objects, that allows multilevel entities to be represented in terms of single level objects. The main qualifying aspect of our approach is that the object interfaces can be provided to users as if multilevel objects were directly supported.
We consider the addition of set-valued methods and multiple inheritance to a simple deductive object-oriented language we defined and studied previously. We show how the previously defined declarative semantics can be extended to provide a natural semantics for inheritance and overriding in this more general setting, and similarly extend our previously defined evaluation procedures.
We present a wide-spectrum algebra and refinement calculus designed to allow one to reason about query optimization in graph-based data models. A query language is wide-spectrum if it can be used to express both user level queries as well as low-level evaluation strategies or access plans. This property enables rule-based query optimization to be viewed as the process of refining expressions in such a language: "non-procedural" sub-expressions are gradually replaced by more "procedural" sub-expressions until an unambiguous access plan results. We begin by presenting an algebra that is wide-spectrum in this sense. One subset of operations within the algebra can be used to define the formal semantics of a non-procedural query language for graph-based data models. Another subset can express common data access paradigms such as an index scan, the "cut" operator in Prolog or the nested-iteration join processing strategy. We then present a refinement calculus over the algebra which defines when one algebraic expression subsumes another. The calculus makes it possible to formally prove the correctness of rewrite rules used in rule-based query optimizers, and is sufficiently expressive to admit rules encoding many forms of semantic query optimization.
Explicitly storing the transitive closure of a relation appears to be a solution providing fast access to recursively defined data. However, update propagations then have to be efficiently processed. This paper focuses on the minimization of the cost of the propagation of the updates from the basic relation to the deduced relation. Only a part of the transitive closure relation is influenced by the basic modification and has to be recomputed; the rest of the transitive closure remains untouched. Basic algorithms for instance- oriented propagations of insertion and deletion are proposed. Moreover, this paper investigates the consideration of set- oriented updates directly. We take into account a set of deleted and/or inserted tuples in a single manipulation. The proposed method maintains an arbitary set- oriented update in less than 2 passes over the transitive closure.
We propose a query-evaluation algorithm for database specifications consisting of overridable rules (defaults) and non-overridable rules (axioms). Both kinds of rules may contain disjunctions. Preferences among the defaults are given by a partial order which corresponds to a subclass relationship allowing multiple inheritance. We use a bottom-up theorem proving procedure. It is applied to the set of (disjunctively) assumed default instances which essentially can again be computed by bottom-up evaluation. Our approach has two main advantages: First, it gives a simple foundation for bottom-up evaluation in the presence of defaults; this can be taken as a basis for different optimizations. Second, in contrast to other deduction algorithms, it is able to handle partially ordered defaults with a skeptical / minimal model semantics.
We describe data structures that allow efficient updates of materialized classes derived from relationship of classes in object bases. Materialization of derived classes reduces costs of retrievals and increases costs of updates. Costs of updates increase remarkably when several paths of objects derive the same object. If object bases satisfy the superkey condition proposed in this paper, consistencies of object bases are maintained by local navigations and the remarkable increase of the costs is avoided. Any object base can be transformed to satisfy the superkey condition by adding extra classes and their objects. In this manner, increasing redundancies allows efficient updates.
The problem of allowing non-monotonic constructs, such as negation and aggregates, in recursive programs represents a difficult challenge faced by current research in deductive databases. In this paper, we present a solution that combines generality with efficiency, as demonstrated by its implementation in the new LDL++ system. A novel and general treatment of set aggregates, allowing for user-defined aggregates, is also presented.
As a foundation for providing semantics for aggregation within recursion, the structure of subsets of partially ordered domains is studied. We argue that the underlying cause of many of the difficulties encountered in extending deductive database semantics to include aggregation is that set construction does not preserve the structure of the underlying domain very well. We study a binary relation ⊏ that is stronger than the standard ⊂, contrasting its properties on domains with differing amounts of structure. An analogous ≻ is defined that is more appropriate than R[ for minimization problems. A class of aggregate functions, based on structural recursion, is defined formally. Proposed language constructs permit users to define their own interpreted functions and aggregates. Several relational algebra operations are not monotonic w.r.t. ⊏. To overcome this problem, unfolding is proposed to “bury” the nonmonotonic operations inside aggregation.
We address the issue of updating derived data in universal relation interfaces and in deductive databases. The proposed approach consists in marking those facts whose deletions are desired, and in processing these marks so as to appropriately answer queries. The database semantics is given in a general framework by fixpoint construction of three derivation operators computing exceptions, positive and negative facts. The presented approach is applied to two different database formalisms using derived facts, namely, universal relation and Datalogneg databases.
In this paper we introduce G-Log, a declarative graphical query language which combines of the expressive power of logic, the modelling power of objectorientedness and the representation power of graphs. As in the case of prolog, G-Log may be used in a totally declarative way, as well as in a "more procedural" way. Furthermore, it provides an intuitive and flexible graphical tool for non-expert database users. We prove that G-Log is a graphical equivalent of the first order predicate calculus. Finally, we study its features as a non-deterministic language and compare it with other existing non-deterministic languages.
In this paper we introduce a logical query language extended with object-oriented typing facilities. This language, called DTL (from DataTypeLog), can be seen as an extension of Datalog equipped with complex objects, object identities, and multiple inheritance based on Cardelli type theory. The language also incorporates a very general notion of sets as first-class objects. The paper offers a formal description of DTL, as well as a denotational semantics for DTL programs.
The object-based event calculus is a modified version of the event calculus which is a general approach to the treatment of time and change in a logic programming framework. We present here the use of the object-based event calculus in describing versioning of objects. We begin by describing the maintenance of a historical object database by the use of event descriptions. We then present the extensions that are necessary to support different kinds of versioning. The aim is to provide a framework where complex changes to objects can be performed in a descriptive way.
Programs in deductive database and programming systems have a natural meaning that is based upon their mathematical reading as logical rules. High-level ‘explanations’ of a program evaluation/execution can be constructed to provide added functionality: (1) To debug a program by following a chain of deductions leading to an unexpected (and possibly incorrect) conclusion; (2) To follow the derivation of certain correct conclusions to determine why and how they are reached; (3) To identify consequences of a (typically, incorrect or unexpected) fact. This functionality can be utilized either to perform post-mortem analysis of a session, or to interactively develop programs by running queries and viewing their deductions simultaneously. ‘Explanations’ of programs are especially important in the context of deductive databases for three reasons: (1) These programs could involve recursion, and hence, the chain of inferences is often not evident. (2) When the input data set is large, it is very difficult for a user to inspect the data and determine which facts lead to which answers, and exactly how. (3) Such programs do not guarantee a fixed evaluation strategy, and this makes it difficult for a user to comprehend unexpected behavior of a program. With this motivation, we have designed and implemented an explanation facility for the CORAL deductive database system. The design is based on the representation of a program evaluation as a set of derivation trees, and the facility provides a high-level explanation of the inferences carried out during program execution. A notable feature of the implementation is the boot-strapped use of CORAL in the implementation of the explanation tool. We believe that an explanation system can provide a novel approach to interactively querying data, and is useful even for standard relational databases.
For a deductive database we present an algorithm to efficiently compute the changes in virtual predicates induced by updates. We first define different classes of potential changes introduced by updates. These definitions are expressed as rules, and merged into the rules defining the database views. This enables the system to determine changes induced by an update with minimum redundancy. Moreover the evaluation of the merged rules mirror the evaluation of the rules defining the views: as a result no new evaluation machinery is needed, and any optimizations applied to the rules defining the views are inherited by the merged rules. The method is introduced by giving a detailed analysis of the difference between two states. We describe a mechanism compiling the original rules into a format amenable to a standard query evaluator. The algorithm is applied to the integrity checking problem. The integrity constraints are boolean views, defined by rules, and their validity after an update is checked by computing the induced changes on predicates defined by these rules.
This paper examines the problem of adding non-deterministic constructs to a declarative database language based on Horn Clause Logic. We revise a previously proposed approach, the choice construct introduced by Krishnamurthy and Naqvi, from the viewpoints of amenability to efficient implementation and expressive power. Thus, we define a construct called dynamic choice, which is consistent with the fixpoint-based semantics, cures the deficiencies of the former approach, and leads to efficient implementations in the framework of deductive databases. Also the new construct extends the expressive power of Datalog programs considerably, as it allows to express negation under Closed World Assumption, as well as a class of relevant deterministic problems.
We distinguish the concepts of types, used for structure and behavioral sharing in object-oriented programming languages, from classes, used as collections in databases. Consequently, our class is not a type. Types are used strictly for structure; a type can be used as the structure for multiple, semantically unrelated, classes. Objects belonging to these classes are said to have the same canonical structure. Classes are collections of objects enhanced with additional features to describe context sensitive information, thus supporting non-canonical view of objects in the class. With the above two classifications of objects, an object may be a member of several classes that are unrelated by the subclass superclass relationships; each class membership models the different roles played by an object in the real world. This paper describes the above two concepts and shows how they are supported in our database programming language, PINOL.
Several approaches have been taken to incorporate integrity constraints into the class definitions of an object-oriented (OO) database. In this work, we generate constraint checks automatically in the basic methods of a class definition. The constraints are derived from the Extended Entity-Relationship (EER) model, and incorporated into the object-oriented classes. Our work investigates the issues in designing an OO database by mapping an EER[1] schema into an Object model[2]. We define a number of basic methods for each class, and automatically generate default class definitions including both attributes and basic methods. In our approach, the constraints are incorporated into the code of the basic methods for each object class.
Deductive object-oriented databases advocate the advantage of combining object-oriented and deductive paradigms into a single data model. Certainly, the query language in such a data model has to reflect the amalgamation because it works as the interface to the user and/or application program. This paper proposes a language to formulate queries as classes related to the schema classes and constrained by an associative membership condition. Answers are then regarded as their instances. The interpretation is based on a deductive database view of queries. Generic query classes are introduced with a simple parameter substitution construct. The syntactic separation of structural and associative conditions opens the way to semantic query optimization: subsumption between the structural parts of queries can be decided efficiently.
