Showing papers on "Tuple published in 1986"

Updating Derived Relations: Detecting Irrelevant and Autonomously Computable Updates

Abstract: Consider a database containing not only base relations but also stored derived relations (also called materialized or concrete views). When a base relation is updated, it may also be necessary to update some of the derived relations. This paper gives sufficient and necessary conditions for detecting when an update of a base relation cannot affect a derived relation (an irrelevant update), and for detecting when a derived relation can be correctly updated using no data other than the derived relation itself and the given update operation (an autonomously computable update). The class of derived relations considered is restricted to those defined by PSJ-expressions, that is, any relational algebra expressions constructed from an arbitrary number of project, select and join operations (but containing no self-joins). The class of update operations consists of insertions, deletions, and modifications, where the set of tuples to be deleted or modified is specified by a selection condition on attributes of the relation being updated.

Toward a multihomogeheous model for a temporal database

Abstract: In a conventional database, out of date information is deleted from time to time to keep the database up-to-date. In some applications it is not appropriate to discard old information. In a temporal database, time values are associated with each data item to indicate its period of validity. We propose a model for temporal databases within the framework of classical relational database theory. Our basic model is homogeneous in the sense that the periods of validity of all the attributes in a given tuple of a temporal relation are identical. The model is realized as a temporal parameterization of static relations. The concepts of normal forms, dependencies, etc., can be extended to our model, allowing the proper initial structuring of the database. We develop relational algebra and tuple calculus for our model and prove their equivalence. We generalize the homogeneous model to a multihomogeneous model which allows us to model a significant part of the real world.

Rule-based transformation of relational queries into iterative programs

Abstract: Over the last decade many techniques for optimizing relational queries have been developed However, the problem of translating these set-oriented query specifications into other forms for efficient execution has received little attentionThis paper presents an algorithm that translates algebra-based query specifications into iterative programs for an efficient execution While the source level operates on sets of tuples, the generated programs manipulate tuples as their basic objects The algorithm incorporates techniques which have been developed in the areas of functional programming and program transformation

Computation-tuple sequences and object histories

Abstract: A record-based, algebraically-oriented model is introduced for describing data for “object histories” (with computation), such as checking accounts, credit card accounts, taxes, schedules, and so on. The model consists of sequences of computation tuples defined by a computation-tuple sequence scheme (CSS). The CSS has three major features (in addition to input data): computation (involving previous computation tuples), “uniform” constraints (whose satisfaction by a computation-tuple sequence u implies satisfaction by every interval of u), and specific sequences with which to start the valid computation-tuple sequences. A special type of CSS, called “local,” is singled out for its relative simplicity in maintaining the validity of a computation-tuple sequence. A necessary and sufficient condition for a CSS to be equivalent to at least one local CSS is given. Finally, the notion of “local bisimulatability” is introduced for regarding two CSS as conveying the same information, and two results on local bisimulatability in connection with local CSS are established.

Database portals: a new application program interface

Abstract: This paper describes the design and proposed implementation of a new application program interface to a database management system. Programs which browse through a database making ad-hoc updates are not well served by conventional embedding of DBMS commands in programming languages. a new embedding is suggested which overcomes all deficiencies. This construct, called a portal, allows a program to request a collection Of tuples at once and supports novel concurrency control schemes.

External semantic query simplification: a graph-theoretic approach and its implementation in Prolog

Abstract: Semantic query simplification utilizes integrity constraints enforced in a database system for reducing the number of tuple variables and terms in a relational calculus query. To a large degree, this can be done by a system that is external to the DBMS. The paper advocates the application of database theory in such a system and describes a working prototype of an external semantic query simplifier implemented in Prolog. The system employs a graph-theoretic approach to integrate tableau techniques and algorithms for the syntactic simplification of queries containing inequality conditions. The use of integrity constraints is shown not only to improve efficiency but also to permit more meaningful error messages to be generated, particularly in the case of an empty query result. The paper concludes with outlining an extension to the multi-user case. Center for Digital Economy Research Stem School of Business IVorking Paper IS-84-5 1

Optimizing the Rule-Data Interface in a KMS

Abstract: Work on integrating systems capable of drawing inferences from knowledge b,wes containing large numbers of logical clauses with relational datab,we systems containing large numbers of facts is described The aim is to realize the derivational power of symbolic logic while at the same time exploiting the set-processing capabilities and potential parallelism of relational data base systems We propose that the interface between the deduction and database components involve set-characterizing relational algebra programs (RAPS) and sets of answer values, rather than proceeding sequentially with single answer tuples being requested and returned from the database system one by one Our design includes a query compiler that translales queries into RAPS, as well as a rule compiler that compiles rules into an elliciently maintainable and incrementally updateable predicate connection graph (PCG), a structure whose use obviates open ended deductive search at query time When prewnted with a query, the system extracts from the PCG a proof schema that represents all possible derivations of the query from the +afional database Structure sharing within this proof schema provides a b,asis for producing from the schema a significantly optimized RAP Direct manipulation of the RAP expression enables fur&r optimization, and the optimized program is then evahmtcd against the database The result is a set of all possible answers to the rluery, produced with minimal scar& of the database Answers may then be combined with certain intermediate rem]Ls and proof schcmn inlormation to gencrate explanations describing how the answers were derived from the knowledge base We describe a prototype implementation of this proposed design and report on preliminary empirical explorations Some results or the explorations are lhat, although the number of derivations represented in a proof schema grows log exponentially with respect to deductive complexity (in one example the number approaches three million), RN’ size appears to grow only linearly with deduc-

Translating Aggregate Queries into Iterative Programs

Abstract: Over the last decade, many techniques for optimizing relational queries have been developed. However, the optimization of queries with aggregation has received little attention. This paper investigates possible improvements for aggregate queries on groups of tuples. We suggest the use of program transformation methods to systematically generate efficient iterative programs for their evaluation. Two transformation steps successively translate a program, which sorts the relation before applying the aggregate function, into an iterative program which performs the aggregation while sorting, thus using less time and space than needed for the execution of the initial program.

Estimating bucket accesses: A practical approach

Abstract: In optimizing database queries one inevitably encounters two important estimation problems. The first problem is to estimate the number of page accesses when selecting k tuples from a relation. The other problem is to estimate the number of different equijoin values remaining after selecting k tuples from a relation. The estimated values strongly depend on how the tuples are distributed over the pages (first problem) and how the equijoin values are distributed over the relation (second problem). It appears to be possible to find restrictive upper and lower limits for these problems in many practical situations. Results derived elsewhere appear to fall significantly outside these limits. Finally, a (time) efficient algorithm to approximate the values to be estimated, is proposed.

Updating Logical Databases Containing Null Values

Abstract: We show that it is natural to extend the concept of database updates to encompass databases with incomplete information in the form of null values, or tuple attribute values that are known to exist but whose exact value is not known. Our approach embeds the incomplete database and the updates in the language of mathematical logic, which we believe has strong advantages over relational tables and traditional data manipulation languages in the incomplete information situation. We present semantics for our update operators, and provide an algorithm to perform the operations. The computational complexity of the algorithm is examined, and a lazy evaluation scheme coupled with simple user-supplied cost limits is recommended to avoid undesirable expense during execution. This paper extends results presented in [Winslett 86a].

Abstract data types in databases: Specification, manipulation and access

Abstract: The basic data types from which records can be constructed in most database management systems are limited to a few simple types such as integers, reals, and character strings. There are many applications, exemplified by office automation, computer-aided design and geographic information systems, that could benefit from management of databases containing the complex objects typically used in programming these systems. We call databases that contain user defined abstract data types object-extended databases. In this paper we examine three aspects of providing support for object-extended databases: their specification, their manipulation by transactions, and access to them via queries. We show that a database specification scheme grounded formally in three abstract data types, finite sets, tuples and lists, accommodates the integration of databases and arbitrary abstract data types from the points of view of database designers, transaction programmers, and query writers and implemented.1

ECRINS/86: An Extended Entity-Relationship Data Base Management System and its Semantic Query Language

Abstract: We propose a DBMS the data model of which is an extension of the Entity-Relationship model of Chen. The main extensions include the specialization and generalization concepts of Smith & Smith and the possibility to define relationships between relationships. In addition we extend the concept of a role in a relationship, to a multi-valued role which enables to associate a set of tuples performing the same function in a relationship. A query language has been designed in order to deal with the enhanced semantic capabilities of the data model supported by the ECRINS/86 system.

Tuple sequences and lexicographic indexes

Abstract: The concept of a tuple sequence is introduced in order to investigate structure connected with relational model implementation. Analogs are presented for the relational operations of projection, join, and selection, and the decomposition problem for tuple sequences is considered. The lexicographical ordering of tuple sequences is studied via the notion of (lexicographic) index. A sound and complete set of inference rules for indexes is exhibited, and two algorithmic questions related to indexes examined. Finally, indexes and functional dependencies in combination are studied.

Updating Derived Relations: Detecting Irrelevant and

Abstract: Consider a database containing not only base relations but also stored derived relations (also called materialized or concrete views). When a base relation is updated, it may also be necessary to update some of the derived relations. This paper gives sufficient and necessary conditions for detecting when an update of a base relation cannot affect a derived relation (an irrelevant update), and for detecting when a derived relation can be correctly updated using no data other than the derived relation itself and the given update operation (an autonomously computable update). The class of derived relations considered is restricted to those defined by PSJ-expressions, that is, any relational algebra expression constructed from an arbitrary number of project, select and join operations (but containing no self-joins). The class of update operations consists of insertions, deletions, and modifications, where the set of tuples to be deleted or modified is specified by a selection condition on attributes of the relation being updated.

Retrieval-By-Unification Operation on a Relational Knowledge Base

Abstract: This paper describes a method for retrieval-byunification (RBU) operations, especially unificationjoin, on a relational knowledge base. The relational knowledge base is a conceptual model for a knowledge base. In this model knowledge is represented by term relations. Terms in the term relations are retrieved with operation called RBUs (i.e., unification-join and unification-restriction). To perform unification-join in the simplest manner, all possible pairs of tuples in term relations should be checked to see if each pair of terms in the tuples is unifiable or not. This would result in an extremely heavy processing load. We propose a method which involves ordering terms and, as result, omitting some pairs from this processing. The paper also describes a method for implementing the unificaiion engine (UE), that is, hardware dedicated to the RBU operations.

An extension of access paths to improve joins and selections

Abstract: A new access method, based upon predicate-tree and previously presented in [GARD 83b, VALD 84, GARD 85], presents major possibilities of applications. The basic method which is implemented, allows the clustering of tuples from a relation when they satisfy some predicate. The aim of this paper, is to show the flexibility of this method and the numerous possibilities of extensions. In addition, to the permanent access paths based upon physical clustering, predicate-trees allow the implementation of classical secondary access paths. We give a method to code the values of several secondary attributes by use of secondary predicate-trees. This method requires a less important storage volume than classical secondary indexes. Predicate-trees can also efficiently speed up the join operation. Clustering information is used to limit the join to relevant pairs of partitions. Our evaluation shows that an improvement ratio of 7 or more versus traditional algorithms can be achieved.

Data abstraction, views and updates in RIGEL

Abstract: Language constructs to support the development of data base applications provided in the programming language rigel are described. First, the language type system includes relations, views, and tuples as built-in types. Tuple-values are introduced to provide more flexibility in writing procedures that update relations and views.Second, an expression that produces sequences of values, called a generator, is defined which integrates relational query expressions with other iteration constructs found in general-purpose programming languages. As a result, relational expressions can be used in new contexts (e.g., as parameters to procedures) to provide new capabilities (e.g., programmer-defined aggregate functions).Lastly, a data abstraction facility, unlike those proposed for other data base programming languages, is described. It provides a better notation to specify the interface between a program and a data base and to support the disciplined use of views.All of these constructs are integrated into a sophisticated programming environment to enhance the development of well-structured programs.

Reducing Recursion to Iteration by Means of Pairs and N-tuples

Abstract: (i) The family \(\mathbb{D}\)of data systems , considered as heterogeneous term- (anarchic-) algebras with a finite number of supports and constructors, has the property that the family \(\mathbb{I}\)of iterative functions mapping algebras into algebras does not change if, inside its definition, the primitive recursion scheme replaces the iteration scheme [Bohm 1986]. The same idea is developed here, for other recursion schemes, neither iterative nor primitive recursive, like the simultaneous (mutual) iteration schemes. Illustrations of such schemes are algorithms or functions more or less familiar in computer science, e.g. functions defined by some limited while schemes.

Capture and analysis of data placement requirements

Abstract: A notation and a method are presented for capturing and analysing information to allow ‘optimised’ placement of tuples from several logical relations to form a physical database. An algorithmic notation to express the requirements of important functions accessing a database and to capture their expected traffic densities is introduced and a straightforward method of deciding on a priority queuing of contending relation-pairs and the associativities between them is developed. The output from these procedures provides the input to techniques for determining the clustering and loading sequence for the relations of a database.

On Program Transformation with Tupling Technique

Abstract: In this paper, we construct a theory for an automatic program transformation with tupling technique. We introduce a purely applicative programming language and formalize a problem to find a tuple for transformation of a recursive program written in the language. We discuss the transformation scheme with the tuple given as the solution to the problem and show that the execution efficiency will be improved by the new scheme. Under a certain constraint, we describe the method to find a tuple for a given program.

One-Sided Recursions.

Abstract: The performance of database systems with recursive query languages can be improved by recognizing simple, easily evaluable classes of recursions and using algorithms tailored to these classes whenever possible. In this paper we identify a useful subset of recursive definitions, the one-sided recursions . We show how to detect one-sided recursions, and give a schema to evaluate selections of the form “column = constant” on a relation defined by a one-sided recursion. Instantiating this schema produces evaluation algorithms that have simple termination conditions, maintain minimal state information, and use selections on the recursively defined relation to restrict the tuples examined during the evaluation. We show that there are no similar algorithms for many-sided recursions. We also prove that it is undecidable whether an arbitrary definition has an equivalent one-sided definition, but show that equivalence to a one-sided recursion is decidable for a large subset of recursions.

Design of secondary storage system of database machine grace using generalized KD‐tree

Abstract: The relational database machine GRACE can execute heavy relational operations such as joins quite efficiently, thereby resolving the bottleneck in the relational database processing. A new bottleneck, however, is expected to appear at accesses to the secondary storage system. We can also eliminate this new bottleneck by partitioning the database into multidimensional cells adaptively to the access pattern to data. As a result, the average number of page accesses is reduced. We developed an adaptive multidimensional clustering technique called the generalized KD-tree method. The method is fully adaptive to the access pattern to data and the distribution of tuples. It was shown that the generalized KD-tree method can reduce the average number of page accesses considerably, even in comparison with other multidimensional clustering algorithms.

Tuple retrieving method of data base

Abstract: PURPOSE:To decrease the number of times of the wasteful retrieving processing by considering the condition of the data base, namely, the discontinuous condition of the key, and skipping the retrieving conditions up to the next effective key value at the discontinuous part. CONSTITUTION:A comparing processing part 421 makes retrieving conditions into zero, reads a head double key 0 on an index 431, compares both, and when both are coincident, a tuple key is transferred to a tuple returning processing part 422. The processing 422 indexes the index 431 with the tuple key, reads the tuple 433 on a data file 432 and returns to a service requesting side 431. When the processing proceeds, the retrieving conditions go to be 101, a tuple key 200 is read from the index 431, and both are not coincident, the comparing processing part 431 uses the tuple key 200 as the retrieving condition. As the result, the coincidence of the retrieving conditions and the tuple key is obtained, and the comparing processing part 421 can transfer 200 to the tuple returning processing part 422 as the next key of a tuple key 100 by one dissident ineffective processing.