Abstract: Building and maintaining high quality knowledge based systems is not a trivial task. Decision tables have sometimes been recommended in this process, mainly in verification and validation. In this paper, however, it is shown how decision tables can also be used to generate, and not just to validate, knowledge bases and how the transformation process from decision tables to knowledge bases can be organized. Several options to generate rules or other knowledge representation from decision tables are described and evauluated. The proposed generation strategy enables the knowledge engineer to concentrate on the acquisition and modelling issues and allows him to isolate the knowledge body from its implementation. The generation process has been implemented for two commercial tools, AionDS and KBMS and has been applied to real world applications.

Abstract: Authorization is an important functionality that every data management system should provide. An authorization mechanism allows different access rights on data items to be selectively assigned to users. Authorization models and mechanisms have been widely investigated in the framework of traditional database systems. The extension of those models and mechanisms to advanced data management systems is quite complex, because those systems are characterized by data models with a larger number of semantic constructs than traditional models, like the relational one. A first authorization model defined for object-oriented (and semantic) database systems has been presented in [20]. In this paper we present an authorization model that substantially extends and revises that model. The most significant extension concerns the support for content-dependent authorization, which was not provided in [20]. Content-dependent authorization is very important in providing an authorization mechanism able to directly support authorization policies of application environments. Moreover, it is a crucial functionality in environments where data objects frequently change their status. In addition, the model presented here differs from the model defined in [20] in that new authorization types are introduced and a finer control of versions is provided. Finally, authorization administration of objects is considered.

Abstract: In this paper we present EVORM, a data modelling technique for evolving application domains. EVORM is the result of applying a general theory for the evolution of application domains to the object role modelling technique PSM, a generalisation of ER, EER, FORM and NIAM. First the general theory is presented. This theory describes a general approach to the evolution of application domains, abstracting from details of specific modelling techniques. This theory makes a distinction between the underlying information structure and its evolution on the one hand, and the description and semantics of operations on the information structure and its population on the other hand. Main issues within this theory are object typing, type relatedness and identification of objects. After a (short) introduction to PSM, this general theory is applied, resulting in EVORM. Besides having a right of its own, the usefulness of the general theory is demonstrated by interpreting its abstract results, resulting in more intuitive rules for EVORM.

Abstract: This paper introduces an approach of discovering concept clusters by decomposing databases. This approach is the fundamental one for developing DBI which is one of sub-systems of the GLS discovery system implemented by us. A key feature of this approach is the formation of concept clusters or sub-databases through analysis and deletion t of noisy data in decomposing a database. Its development is based on the concept of Simon and Ando's near-complete decomposability that has been most explicitly used in economic theory. In this approach, the process of discovering concept clusters from databases is a process based on incipient hypothesis generation and refinement, are many kinds of learning methods, in which the methods of data-driven and knowledge-driven are included, are cooperatively used in multiple learning phases, so that a more robust, general discovery system can be developed.

Abstract: This article presents a framework developed for accomodating various object migrations in ‘statically-typed’ object databases. Requirements for supporting object migrations are stipulated, and a conceptual model for describing and facilitating different kinds of migrations is described. Associated issues of controlling such migrations are then addressed, along with an initial investigation on the interence of implied migration paths and the completeness of migration operators. Some guidelines are then given to help users conduct migrations more effectively. An implementation prototype on top of an object-oriented database system was built, which embodies full support of all migration types specified in the migration model.

Abstract: The database multiple-query optimization can be achieved by analyzing multiple-query sequences at a level below that used by current optimizers, but above the low-level executable code. In this paper, the concept of the ‘algorithm-level’ representation of a database program is defined and optimization techniques that can be applied to the algorithm-level representation are discussed. Some techniques extend existing concepts, while others are new. In this paper, we also show multiple-query optimization can be performed across the update queries.

Abstract: The topic of access control modes is a very important subject in the field of information protection systems. In this paper, we shall propose a new access control mode, the subject-object-list (SO-list), for a system which adds, removes, and updates subjects and objects frequently. The main advantage of the SO-list is that the number of lists remains constant despite the changes in the number of subjects/objects. Furthermore, by applying the key-lock-pair mechanism to the list, we allow a new subject/object to be added to or an existing subject/object to be removed from the system without recomputing a large number of key/lock values. Thus, our method achieves real dynamicism.

Abstract: In this paper we introduce the database design tool EDO: an Evolutionary Database Optimizer. The term ‘evolutionary’ refers to a basic feature of the tool. After generating an initial pool of preliminary internal representations for a given conceptual data model, EDO allows a database designer to activate evolution strategies, modifying the preliminary internal representations into more desirable ones. The quality of the internal representations found as yet is used to perform a guided walk through the solution space of alternative internal representations for the conceptual model under consideration. This quality (called fitness) takes into account the expected storage space and the expected average response time of a candidate internal representation.

Abstract: Modern database applications require advanced means for modelling system structure and dynamics. Temporal logic has been proven to be a suitable vehicle for specifying the possible evolution of objects to be stored in databases. Past-directed temporal logic, as a means to describe the influence of the historical evolution of a database on applicable state changes, is one facet for the specification of object behaviour. The conceptual modelling language TROLL emphasizes the behaviour of objects over the course of time. Especially the restriction of events with preconditions in past-directed temporal logic has to be monitored, when a system specified in TROLL is implemented or prototyped. In this report we introduce a technique for monitoring (past-directed) temporal preconditions during database r runtime. This technique avoids storing the whole database history for evaluating temporal preconditions. Instead, little information about the database history is derived for specific temporal preconditions using transitions graphs. This derived information is evaluated in later database states, when the temporal preconditions is to be checked. We also describe a possible integrity monitor able to check temporal preconditions during database runtime. Such a monitor is specified locally to objects with advantages for distributed implementations. The dependency of the checking procedure on update operations leads to an optimized monitoring process that makes an efficient control of dynamic integrity constraints possible. The monitoring process itself is specified with the language TROLL . An implementation of an integrity monitor can therefore be tackled together with the language implementation. The advantages and future extensions of the proposed monitoring process and its modelling are briefly discussed.

Abstract: It is widely acknowledged that clustering is a cornerstone for the performance of database management systems. In particular, object-oriented databases have special properties which make clustering even more important for them than for conventional database models. In this paper, a survey is presented for the state of the art in the field of clustering in object bases. Several design dimensions are discussed and used as a basis for comparing different systems. Moreover, a set of selection guidelines and evaluation criteria are proposed and finally, open questions and future research directions are outlined.

Abstract: This paper introduces the E/S knowledge representation model and describes a system based on that model. The model takes ideas from KL-ONE and ER, and its main strength is the direct representation of n-ary relationships. The system is classification-based, and therefore organizes its knowledge in hierarchies of structured intensional objects and offers a set of services to reason about intensional objects, to store extensional objects and to make inferences on the stored knowledge.

Abstract: There has been a considerable amount of research into the provision of explicit representation of control regimes for resolution-based theorem provers. However, most of the existing systems are either not adequate in that they do not allow the user to express any arbitrary control regime, or are too inefficient to be of practical use. In this paper a theorem prover, ACT-P, which is adequate but retains satisfactory efficiency is presented. It does so by providing a number of user-changeable heuristics which are called at specific points during the search for a proof. The set of user-changeable heuristics was determined on the basis of a classification of the heuristics used by existing resolution-based theorem provers.

Abstract: Allocation of rules to sites in a distributed deductive database system is an important and challenging task especially for a large knowledge base We identify communication cost in rule execution to be the primary basis for decomposing a global knowledge base into clusters for their allocation to sites We show that the problem of optimal allocation is a 0–1 quadratic programming problem, which has prohhbitive execution times for large knowledge bases We propose an efficient heuristic algorithm for rule allocation and study its performance experimentally We represent a knowledge base as a hierarchy and characterize it in terms of height and inherent clusters with overlaps The experimental results of the heuristic algorithm on random hierarchies as well as on hierarchies with varying heights and overlaps are seen to be close to the optimal solution

Abstract: Data fragmentation is a well-known technique used in distributed database design to support efficient query processing. In deductive databases and knowledge bases, one distinct operation is the computation of transitive closures. In this paper, we employ a fragmentation approach to deductive databases. Fragmentation techniques are investigated in distributed database environments for parallel recursive query processing. Based on the novel fragmentation scheme, a new parallel transitive closure algorithm is proposed. Compared with previous algorithms, our algorithm can explore a much higher level of parallelism with very little communication overhead increase.

Abstract: In this paper, new replica control algorithms, called the enhanced tree quorum (ETQ) algorithm and the multiple tree quorum (MTQ) algorithm, are proposed to manage replicated data in distributed database systems. These algorithms provide high availability for read and write operations by imposing a logical structure of modified tree with a backup root on data copies in ETQ, and multiple trees on data copies in MTQ. With ETQ algorithm, a read operation is limited to a data copy in the best case, and a write operation is allowed as long as one of the roots and the majority of the children of each node selected are available in the tree. With MTQ algorithm, a read operation is limited to a couple of data copies, and a write operation is allowed as long as the majority of the roots of the trees and the majority of the children of each node selected are available. Compared to other algorithms, ETQ and MTQ require lower message cost for an operation, while providing higher availability.

Abstract: The inadequacy of the Closed World Assumption in dealing with indefinite information has led to the Generalised Closed World Assumption and the Extended Generalised Closed World Assumption. However, these approaches have serious shortcomings. In this paper, the Indefinite Closed World Assumption is proposed to overcome the shortcomings. It provides a desirable and simple logical interpretation of a database containing indefinite information.

Abstract: In this paper we propose a new approach to provide us with (universal and existential) quantification in a visual data manipulation language called PIM algebra. Overall ideas are two basic constructs, one for universal (ℬ) quantifier and another for existential (∃) quantifier. Then a nesting feature is considered to obtain general expressive power. The major contribution of this paper is that, for every query specification with any depth of nesting of quantification, there is an equivalent canonical form which can be easily processed by database management systems.

Abstract: We study a general class of single linear recursions and the properties of their expansions by analyzing the structures of the recursions. We show that the expansions of a linear recursion of this class are very regular in that the variable connections are heavily shared and change periodically with respect to the expansions. The variable connections can be precisely characterized as static bindings and chain connections. We conclude that a single linear recursion under our assumptions either is bounded or can be expressed as chain recursions. This study contributes to query processing, because it provides the basis for rule compilation as a general and powerful technique for query processing. Combined with query information, the expansion properties of the recursion provide optimized query-processing plans. >

Abstract: Logic programming with abductive reasoning is used during the realization of a data dictionary with a particular methodology. Some methodological steps are represented by means of a set ofrules augmented with integrity constraints which capture the presence of incompatible concepts. Explanations for incompatibility can be inferred by exploiting abductive reasoning . To this end a new proposal for the computation of hypotheses in an abductive framework where the theory is a general logic program, is presented. It is based on a suitable manipulation of minimal three-valued models of the logic program. A method to compute three-valued minimal models of a general logic program is given.

Abstract: One of the major assumptions in designing knowledge representation formalisms in the KL-One family, was the so-called ‘intensional representation’. An intensional representation is required when two descriptions have to be compared, or when they are interpreted by qualitative processes; in other words, many processes can be activated by using the global structure of a concept, and by interpreting its properties and the relationships between these properties. In this perspective, an intensional semantics for a typical terminological language has been designed, which is quite different from the extensional models proposed so far. The semantics of the language is similar to that of data types in programming languages. Primitive concepts are denoted by a set of values. Defined concepts are denoted by their properties. A denotation thus contains the minimum number of properties which are required for an individual to be an instance of a generic concept. More precisely, the denotation is the Cartesian product of the sets denoting the properties of the genetic concept (deduced from its syntax). A role is denoted by a function which, given a tuple, returns the values of the property which individuates the role. An individual is created by instantiating the properties of the relative generic concept, used as a guide. As a result, this process creates a tuple whose elements are the instantiating properties. The instantiation chain terminates by instantiating primitive concepts on the basis of their denotation. A deeper integration between the entire system and any programming language can be reached, which implicitly gives rise to an object-oriented system. In other words, it is possible to introduce an individual concept into a programming language, like any other data type. For instance, an individual concept is passed to a function as a parameter; once it has been verified that this individual is an instance of a generic concept, or of one of its subconcepts, the function will be executed. Furthermore, an increase in the expressive power is obtained, since it makes it possible to give a formal meaning to all kinds of recursive definitions of individual and generic concepts.

Abstract: This paper deals with the definition of a rule-based update language for complex object databases. Several update operators are introduced, which correspond to basic manipulations of data entities with object identity. These operators can be used in rule bodies for specifying complex update transactions. The syntax and the semantics of the language is given in the framework of CO, a simple data model for complex objects with identity. An interpreter of the language is defined and its correctness is discussed. Finally, the issue of maintaining database consistency with respect to several kinds of integrity constraints is illustrated.

Abstract: Explicitly storing the transitive closure of a relation appears to be a solution providing fast access to recursivelu defined data. However, two problems are to be solved: (i) update propagations have to be efficiently processed and (ii) efficient access and limited storage space have to be reconciled. This paper focuses on the minimization of the cost of the propagation of the updates from the base relation to the deduced one. Only a part of the transitive closure relation is influenced by the base modification and has to be recomputed. Algorithms for instance-oriented propagations of insertion and deletion are proposed. Then, we take into account a set of deleted and/or inserted tuples in a single manipulation. The proposed method maintains an arbitrary set-oriented update in no more than 2 passes over the transitive closure. The execution times are decreased by the intensive use of parallelism; the explicit transitive closure is divided horizontally into several fragments, clustered on a set of disks, and then, processed by several processors. A shared-nothing implementation is investigated.

Abstract: Consider a table of nd-dimensional records, grouped into b buckets, and a set Q = {(Qh, wh)} of weighed partial-match conditions, where wh is the relative frequency of Qh. Let n(Qh) be the number of records which satisfy Qh, and b(Qh) the number of buckets in which these records are found. The problem we consider is the individuation of the optimal ordering field which minimizes the sum of accessed buckets, B(Q) = Σhwh × b(Qh). An exact solution requires the records to be sorted according to the values of each of the d fields in turn with an overall time complexity, evaluated as a function of bucket accesses, of O(d × b log b). We present an approximate O(b) algorithm which estimates the optimal ordering without the need to sort the table at all. The algorithm makes use of a probabilistic counting technique, known as linear counting, which requires a single scan of the table. Experimental results show that in most cases the approximate solution agrees with the exact one.

Abstract: The relational database model is defined in terms of sets, whereas SQL needs the DISTINCT option for explicit duplicate removal. We define the underlying concept of duplicate tuples, generalize the operators of the relational algebra and study the connection with logic. It is shown that ‘baggy’ operators violate classical equivalences. The generalized system is applied in a formal interpretation of SQL.

Abstract: Multiple-query processing has received a lot of attention recently. The problem arises in many areas, such as extended relational database systems and deductive database systems. In this paper we describe a heuristic search algorithm for this problem. This algorithm uses an improved heuristic function that enables it to expand only a small fraction of the nodes expanded by an algorithm that has been proposed in the past. In addition, it handles implied relationships without increasing the size of the search space or the number of nodes generated in this space. We include both theoretical analysis and experimental results to demonstrate the utility of the algorithm.

Abstract: The dependency inference problem is to find a cover of the set of functional dependencies that hold in a given relation. The problem has applications in relational database design, in query optimization, and in artificial intelligence. The problem is exponential in the number of attributes. We develop two algorithms with better best case behavior than the simple one. One algorithm reduces the problem to computing the transversal of a hypergraph. The other is based on repeatedly sorting the relation with respect to a set of attributes.

Abstract: One of the main characteristics of knowledge representation systems based on the description of concepts is the clear distinction between terminological and assertional knowledge. Although this characteristic leads to several computational and representational advantages, it usually limits the expressive power of the system. For this reason, some attempts have been done, allowing for a limited form of amalgamation between the two components and a more complex interaction between them. In particular, one of these attempts is based on letting the individuals to be referenced in the concept expressions. This is generally performed by admitting a constructor for building a concept from a set of enumerated individuals. In this paper we investigate on the consequences of introducing this type of constructor in the concept description language and we provide some complexity results on it.

Abstract: Making a database system active to meet the requirements of a wide range of applications entails developing an expressive event specification language and its implementation. Extant systems support mostly database events and in some cases a few predefined events. This paper discusses an event specification language (termed Snoop) for active databases. We define an event, distinguish between events and conditions, classify events into a class hierarchy, identify primitive events, and introduce a small number of event operators for constructing composite (or complex) events. Snoop supports temporal, explicit, and composite events in addition to the traditional database events. The novel aspect of our work lies not only in supporting a rich set of events and event expressions, but also in the notion of parameter contexts. Essentially, parameter contexts augment the semantics of composite events for computing their parameters. For concreteness, we present parameter computation for the relational model. Finally, we show how a contingency plan that includes time constraints can be supported without stepping outside of the framework proposed in this paper.

Abstract: This paper describes a rule-based query optimizer. The originality of the approach is through a uniform high-level rule language used to model both query rewriting and planning, as well as search strategies. Rules are given to specify operation permutation, recursive query optimization, integrity constraint addition, to model join ordering and access path selection. Therefore, meta-rules are presented to model multiple search strategies, including enumerative and randomized search. To illustrate these ideas, we describe a query optimizer for an extensible database server that supports abstract data types, complex objects, deductive capabilities and integrity constraints. A prototype of the query optimizer proposed in this paper is operational and has been demonstrated at the 1991 ESPRIT week in the EDS project.