Book

ICDT '88: 2nd International Conference on Database Theory Bruges, Belgium, August 31 – September 2, 1988 Proceedings

Authors:

Abstract

This volume is the proceedings of the second International Conference on Database Theory (ICDT) held in Bruges, Belgium, August 31 - September 2, 1988. ICDT intends to provide a European forum for the international research community working on theoretical issues related to database and knowledge base systems. The proceedings of this conference contain all invited and accepted papers, which represent the latest results obtained in ongoing research in database theory worldwide. Most major themes of research in database theory are covered in ICDT '88: the relational model, logic and databases, object-oriented databases, deductive databases, conceptual models, analysis and design of data structures, query languages, concurrency control and updates and transactions.

Chapters (22)

We consider the main features of updates in databases. Recent results on updates are briefly described and used to raise various questions. It is argued that well-accepted query properties like safety and determinism should not be strictly enforced in the context of updates. The issue of declarative versus procedural update languages is also addressed. Finally, update-based database specifications are considered and compared to more traditional approaches.
The seventies have been the decade of the relational model. In the eighties, there is a renewed interest and activity in the database area. Most of it is concerned with so called "advanced systems for new types of applications". In this activity, much emphasis is placed on the development of new data models and languages. The data models include complex objects, which are in essence hierarchical structures, and various flavors of object oriented models. Data manipulation languages include extensions of the classical algebra and calculus based languages to some of the new models, logic programming style languages, and versions of object oriented languages. The paper discusses extensions of the relational model that allow users to specify and manipulate structurally complex objects and their languages. The emphasis is on formal models and languages. In particular, we describe a formal model for objects with identity, and declarative languages for the model.
This paper describes some results of a recent project to develop a theory for reasoning about atomic transactions. This theory allows careful statement of the correctness conditions to be satisfied by transaction-processing algorithms, as well as clear and concise description of such algorithms. It also serves as a framework for rigorous correctness proofs.
Without Abstract
We present a formal semantics for rule-based systems with uncertainty (this field has also become known as quantitative logic programming). Unlike previous works, our framework is general enough to accommodate most of the known schemes of reasoning with uncertainty found in the existing expert systems. We provide a rigorous treatment of the issue of evidential independence, and study its impact on the semantics. To the best of our knowledge, this issue has not been addressed before in the literature on quantitative logic programming. In expert systems evidential independence received only an ad hoc treatment, while the approaches found in the theory of evidential reasoning are feasible only in small scale systems. We discuss the problem of query optimization and, as a first step, present a quantitative semi-nave query evaluation algorithm — generalization of a method well-known in deductive databases. Treatment of negation and conflicting evidence based on, so called, support logic is given in the last part of the paper, where we extend the semantics of stratified programs to deal with uncertainty.
In this paper a theoretical framework for efficiently checking the consistency of deductive databases is provided and proven to be correct. Our method is based on focussing on the relevant parts of the database by reasoning forwards from the updates of a transaction, and using this knowledge about real or just possible implicit updates for simplifying the consistency constraints in question. Opposite to the algorithms by Kowalski/Sadri and Lloyd/Topor, we are neither committed to determine the exact set of implicit updates nor to determine a fairly large superset of it by only considering the head literals of deductive rule clauses. Rather, our algorithm unifies these two approaches by allowing to choose any of the above or even intermediate strategies for any step of reasoning forwards. This flexibility renders possible the integration of statistical data and knowledge about access paths into the checking process. Second, deductive rules are organized into a graph to avoid searching for applicable rules in the proof procedure. This graph resembles a connection graph, however, a new method of interpreting it avoids the introduction of new clauses and links.
Previous work has addressed the issues of idempotence and boundedness for various restricted classes of Horn-clause queries. In this paper, we consider queries consisting of a single clause containing a single predicate symbol. As such, these queries are a notational variant of the full, untagged tableau queries with recursive semantics. The study of the idempotence and boundedness for single-clause, single-predicate queries has previously been restricted to the typed case. We generalize these results to obtain syntactic, polynomial-time computable characterizations of idempotence for certain classes of untyped queries.
Consider a set of records, where each record is identified by a unique key. The records are accessed based on a set of access probabilities and are to be arranged lexicographically using a binary search tree. If is known a priori, it is well known [7] that an optimal binary search tree may be constructed using and . We consider the case when is not known a priori. A new restructuring heuristic is introduced that requires three extra integer memory locations per record, and this restructuring of the tree is performed only if it decreases the weighted path length of the overall resultant tree. We also present a space optimized version of the latter restructuring mechanism which requires only one extra integer field per record. We show that the cost of the tree is reduced by each restructuring operation, and present experimental results to demonstrate the superiority of our algorithm over all other reported efficient static and dynamic schemes.
An equivalence algorithm for fan-out free queries, which form an untyped subclass of conjunctive queries, based on an extension of the implication graph technique is presented. This algorithm runs in O(n2) time where n is the size of the queries involved. This algorithm subsumes all known equivalence testing algorithms for various subclasses of fan-out free queries.
The optimization of two-way joins is studied in order to minimize the response time in a partitioned database. We assume that the background communication network is capable of parallel transmission, which differentiates the response time measure from the total cost measure. However, we do not make the standard simplifying assumption that communications between different sites is uniform, which results in a nonlinear optimization formulation of the problem. Subsequently, we derive a fast polynomial algorithm to solve the problem. Two less general algorithms are also proposed to explore the effect of local semijoins and remote semijoins as reducers. Finally, computational experiments are carried out to investigate the trade-off between the computation time and the quality of solutions as well as to analyze the sensitivity of the solutions to various parameters of our model.
In this paper, we consider the problem of integrating a production rule language, named RDL1, with a relational DBMS. A production rule in RDL1, consists of a condition part which is a relational calculus expression and of an action part which is a sequence of database updates. The main problem addressed in this paper is to determine whether a rule program can be computed as a relational algebra program, i.e., whether the initial semantics of the program is not modified by a set-oriented or relational computation. First, we define the syntax and the semantics of the RDL1 language which is given as the sequence of database states reachable by the computation of the program. We conjecture that deciding if a rule is relational computable is an undecidable problem and then, propose sufficient conditions to decide if a rule is relational computable. We present a general method to check the validity of these conditions. Finally, we propose two algorithms which are derived from the previous method. The first one gave sufficient syntactic conditions for a rule to be relational computable. The second one gave sufficient semantic conditions and leads to check integrity constraints over the database to decide whether a rule is relational computable.
This paper formalizes inheritance and genericity in the context of object oriented databases. We present a uniform view for objects and types. We model, in the same framework, multiple inheritance and unconstrained genericity. We plan to use this model as the theoretical foundation for the O 2 object-oriented database system.
Representing and manipulating complex (database) objects are important issues in the semantic database models and object-oriented database models, most of which have a rich expressive power for complex objects. In this paper, we will focus on the manipulation of complex objects, and introduce the notions and the operations for abstracting complex objects. We introduce the notion of "element-based" generalization relationships between complex objects, and two new abstraction operators: reduction and unification. Their algebraic properties are then formally investigated especially for "set-type" complex objects.
We investigate the complexity of query processing in the logical data model (LDM). We use two measures: data complexity, which is complexity with respect to the size of the data, and expression complexity, which is complexity with respect to the size of the expressions denoting the queries. Our investigation shows that while the operations of product and union are essentially first-order operations, the power set operation is inherently a higher-order operation and is exponentially expensive. We define a hierarchy of queries based on the depth of nesting of power set operations and show that this hierarchy corresponds to a natural hierarchy of Turing machines that run in multiply exponential time.
We extend the concept of domain independence from queries and databases to disjunctive databases. Informally, a domain independent disjunctive database is one for which the set of correct answers to any domain independent query is independent of the domains of variables in the database statements. We prove that every allowed stratified disjunctive database is domain independent and that every domain independent disjunctive database has an equivalent allowed disjunctive database. We also discuss a generalization and properties of two alternative definitions.
Usually information comes into a data base by input of documents with fixed structure. In this paper, the process of input in hierarchical data base is formally described. A data base is considered as a result of input of documents and its update is considered as an update of some of the documents with corresponding update of the state of the data base. An algorithm of decomposition of the data base to the source documents is given. The algorithm works in a time that is linear in a volume of input information. Basing upon this algorithm, an algorithm of update with the same time of complexity is obtained.
Without Abstract
First steps are taken in examining the view update problem in deductive databases. The class of recursive definite deductive databases is examined. A view update is defined as a statement of factual logical consequence of the deductive database. A translation is a minimal update on the facts of a deductive database such that the view update holds. The number of translations for a view update is exponential in the size of the database. Algorithms for view updates are presented and proven correct. They are based on SLD-resolution and are independent of the computation rule. Finally, as an example of a method for reducing the number of possible translations of a view update, rule annotations are introduced. A small number of unique annotations (proportional to the size of the database) is shown to produce unique translations of view updates.
The concurrency control problem is examined for transactions as they appear at the conceptual level in a concrete database model. Specifically, a class of widely accepted update transactions in relational databases is studied with respect to concurrency control. It is shown how static serializability testing, as well as dynamic scheduling, can be improved by making use of the semantic information available at the conceptual level on transactions and database constraints.
A database used by engineering or manufacturing applications for analysis and design purposes is called a design database. Here data items represent the actual physical structure of engineering parts and components. A design process can be thought of as starting with certain base data items or design objects, and deriving others from them. Several alternate designs may be tried from the same set of base objects. Designs with several sets of base objects may also be tried. Hence several versions of various data items may exist in the system simultaneously. Then consistent versions must be used in each derivation. Also a concurrency control mechanism for design database systems must allow keeping various versions until the end of the design process. In this paper we propose a formal definition of version consistency expressed in terms of transaction histories. This allows checking version consistency from a history graph constructed from transaction processing. The version consistency checking algorithm takes polynomial time. We also demonstrate that a notion called *-serializability is an appropriate correctness criterion for concurrent executions in design databases. This is distinct from view-serializability which is accepted as the appropriate criterion for databases used for business and administrative transaction processing. We show that *-serializability of a version consistent history can be checked in polynomial time. In contrast checking *-serializability of a not necessarily version consistent history is NP-complete. It turns out that both version consistency and *-serializability can be checked using the same history graph.
Without Abstract
We propose in this paper a protocol aimed at managing replicated data with many copies more efficiently. Our protocol, called Majority Consensus Voting with Tokens generalizes the primary copy approach by allowing for more than one primary copy. Since primary copies are identified by the ownership of a token, the protocol allows for easy transfer of tokens from one copy to another to respond to changing access patterns. Tokens owned by failed primary copies can also be reassigned to some live copy to enhance data availability. Upper and lower bounds for the availability of replicated data objects managed by the MCVT protocol are derived under very general probabilistic hypotheses. We show that MCVT significantly improves upon the availability and reliability offered by the primary copy protocol without incurring the high overhead of most other extant protocols.
ResearchGate has not been able to resolve any citations for this publication.
ResearchGate has not been able to resolve any references for this publication.