Showing papers on "Tuple published in 1987"

Of Nests and Trees: A Unified Approach to Processing Queries That Contain Nested Subqueries, Aggregates, and Quantifiers

Abstract: Existing query optimizers focus on Restrict-Project-Join queries. In practice, however, query languages such as SQL and DAPLEX have many powerful features (eg., control over duplicates, nested subqueries, grouping, aggregates, and quantifiers) that are not expressible as sequences of Restrict, Project, and Join operations. Existing optimizers are severely limited in their strategies for processing such queries; typically they use only tuple substitution, and process nested subquery blocks top down. Tuple substitution, however, is generally inefficient and especially so when the database is distributed. Hence, it is imperative to develop alternative strategies. This paper introduces new operations for these difficult features, and describes implementation methods for them. From the algebraic properties of these operations, new query processing tactics are derived. It is shown how these new tactics can be deployed to greatly increase the space of interesting strategies for optimisa tion, without seriously altering the architecture of existing optimisers. The contribution of the paper is in demonstrating the feasibility and desirability of developing an integrated framework for optimising all of SQL or other query languages that have similiar features.

The POSTGRES data model

Abstract: : This paper describes the data model for POSTGRES, a next-generation extensible database management system being developed at the University of California StR86 The data model is a relational model that has been extended with abstract data types, data of type procedure, and attribute and procedure inheritance These mechanisms can be used to simulate a wide variety of semantic and object-oriented data modeling constructs including aggregation and generalization, complex objects with shared subobjects, and attributes that reference tuples in other relations

A Multilevel Relational Data Model

Abstract: A multilevel relational data model that meets the basic operational requirements for a multilevel database system is described. The model is an extension of the standard relational model, and consists of multilevel relations, which contain classification attributes as well as data attributes; multilevel relational integrity rules, which extend the integrity constraints of the relational model in order to pro vide consistency for data at different access classes, including data that becomes "polyinstantiated," a decomposition method for mapping all multilevel real relations into standard (single-level) base relations; and multilevel relational operators, which perform the functions of their counterparts in the standard relational model, while also labeling derived tuples with access classes. The model is defined in terms of the standard relational model, but lends itself to a design and implementation that offers a high level of assurance for mandatory security.

Safety of recursive Horn clauses with infinite relations

Abstract: A database query is said to be safe if its result consists of a finite set of tuples If a query is expressed using a set of pure Horn Clauses, the problem of determining whether it is safe is in general undecidable In this paper, we show that the problem is decidable when terms involving function symbols (including arithmetic) are represented as distinct occurrences of uninterpreted infinite predicates over which certain finiteness dependencies hold. We present a sufficient condition for safety when some monotonicity constraints also hold.

Implementation of tuple space machines

Abstract: The language Linda proposed by Gelernter has a number of characteristics which make it a potentially powerful tool for parallel and distributed computing. One of its most important characteristics is tuple space, a communication model based on a logical shared memory. The degree to which Linda achieves its potential depends strongly on the implementation of tuple space. The thesis of this work is that tuple spaces can be implemented with reasonable efficiency on a variety of multi-processor architectures. We attempt to establish this thesis by means of an existence proof. To this end, two implementations will be discussed. One is for the Bell Lab's S/Net machine, a bus-based multiprocessor. Here our primary concern was low-level communication management. The second implementation was for two examples of shared-memory architecture: the Encore Multimax and the Sequent Balance. Freed of explicit communication concerns, this effort concentrated on building a more sophisticated run-time system that is supported by a detailed compile-time analysis of the Linda source code. Timings for a variety of test programs for each of the implementations will be presented. Extensions to the compile-time analysis and the implications of such extensions for run-time systems will also be discussed.

Design and evaluation of algorithms to compute the transitive closure of a database relation

Abstract: Recursive query evaluation is a capability of deductively-augmented database systems that conventional database systems do not support well, if at all. Many recursive queries involve computation of the transitive closure of a relation. Previously published algorithms for transitive closure are iterative in nature, performing repeated joins, unions, and differences until convergence is obtained. In this paper, we present an adaptation of Warren's algorithm for computing the transitive closure of a relation. Warren's algorithm was originally designed for a bit matrix representation of a binary relation; we have adapted it for use with a binary relation represented as a set of tuples, as in a relational database management system. This adapted algorithm computes the transitive closure in two passes over the relation. We analyze the performance of this algorithm, and compare it to the performance of two algorithms based on relational algebra: an iterative algorithm, and an improved version of the iterative algorithm that eliminates unnecessary I/O at the expense of more computation. We evaluate the performance of the algorithms for different source relation sizes, available memory sizes, join selectivities, and maximum path length. Our results show that no algorithm has uniformly superior performance; the adaptation of Warren's algorithm is superior when the source and result relations are not too much larger than main memory. We conclude that in future systems with large main memory, Warren's algorithm generally performs best, and thus should be implemented with the option of switching to an iterative algorithm when the source or result sizes are very large.

A fully abstract semantics for data flow nets

Abstract: Two semantic models for data flow nets are given. The first model is an intuitive, operational model. This model has an important drawback: it is not compositional. An example given in [Brock & Ackerman 1981] shows the non-compositionality of our model. There exist two nets that have the same semantics, but when they are placed in a specific context, the semantics of the resulting nets differ. The second one is obtained by adding information to the first model. The amount of information is enough to make it compositional. Moreover, we show that we have added the minimal amount of information to make the model compositional: the second model is fully abstract with respect to the equivalence generated by the first model. To be more specific: the first model describes the semantics a data flow net as a function from (tuples of) sequences of tokens to sets of (tuples of) sequences of tokens. The second one maps a data flow net to a function from (tuples of) infinite sequences of finite words tO sets of (tuples of) infinite sequences of finite words.

A fully abstract semantics for data flow nets

Abstract: Two semantic models for data flow nets are given. The first model is an intuitive, operational model. This model has an important drawback: it is not compositional. An example given in [Brock & Ackerman 1981] shows the non-compositionality of our model. There exist two nets that have the same semantics, but when they are placed in a specific context, the semantics of the resulting nets differ. The second one is obtained by adding information to the first model. The amount of information is enough to make it compositional. Moreover, we show that we have added the minimal amount of information to make the model compositional: the second model is fully abstract with respect to the equivalence generated by the first model. To be more specific: the first model describes the semantics a data flow net as a function from (tuples of) sequences of tokens to sets of (tuples of) sequences of tokens. The second one maps a data flow net to a function from (tuples of) infinite sequences of finite words tO sets of (tuples of) infinite sequences of finite words.

Non first normal form relations and recursive queries: An SQL-based approach

Abstract: The work presented in this paper is an attempt to combine two different but closely related research areas in the data base field, namely the quite heavily investigated question of recursive queries in relational data bases on the one hand and the introduction of non first normal form relations on the other. This paper proposes the integration of recursive queries and non first normal form relations by providing a recursion mechanism which can be nested according to the structure of a non first normal form relation. It is shown by examples that this method can be used to formulate queries which are rather cumbersome if only flat relations are used. Especially, in some cases the problem of performing a selection on a recursively defined relation disappears. This question has been the topic of several research papers recently. Moreover, many queries can be formulated in a more natural way than in the world of flat tuples. Therefore, nested recursive queries in combination with non first normal form relations provide a contribution to the problem of modelling complex data.

Handling redundancy in the processing of recursive database queries

Abstract: Redundancy may exist in the processing of recursive database queries at four different levels precompilation level, iteration level, tuple processing level and file accessing level. Techniques for reducing redundant work at each level are studied. In the precompilation level, the optimization techniques include removing redundant parts in a rule cluster, simplifying recursive clusters and sharing common subexpressions among rules. At the iteration level, the techniques discussed are the use of frontier relations and the counting method. At the tuple processing level, we use merging and filtering methods to exclude processed drivers from database reaccessing. Finally, at the file accessing level, I/O cost can be further reduced by level relaxation. We conclude that even for complex recursion, redundant database processing can be considerably reduced or eliminated by developing appropriate algorithms.

Implementing relational database operations in a cube-connected multicomputer system

Abstract: Parallel architectures for database processing should incorporate parallel CPU as well as parallel I/O (disk access) capability. The need to support parallel I/O gives rise to two important issues - data combination and non-uniform data distribution. Strategies for performing database operations in a cube-connected multicomputer system with parallel I/O are presented in this paper. The cube interconnection subsumes many other structures such as the tree, ring, etc. This property is exploited to efficiently support database operations such as Select, Aggregate, Join, and Project. The strategies presented here are unique in that they account for the non-uniform distribution of data across parallel paths by incorporating data redistribution steps as part of the overall algorithm. The two main data redistribution operations used are tuple balancing and merging. A simple analysis of the join and project operations is carried out assuming non-uniform data distributions. A more detailed simulation and study of issues related to query processing will be carried out as part of the future work.

Integrity constraint checking in deductive databases using the Prolog not-predicate

Abstract: In a deductive (or relational) database, integrity constraints are data dependencies which database states are compelled to obey. Different ways of expressing integrity constraints were proposed in several papers, e.g. tuple calculus, closed first-order formula, clause, etc. In this paper, we propose a special form of closed first-order formula, called IC-formula, which uses the Prolog nested not-predicate to express integrity constraints. The IC-formulas are more expressive than other existing ways of expressing integrity constraints. The soundness and completeness of the method for verifying IC-formulas in a deductive database is proved. The full checking of the IC-formulas of a deductive database can be implemented easily by Prolog systems. Methods for doing incremental integrity constraint checking for the operations of inserting, deleting, and modifying a tuple in a relational or deductive database are presented. The concept of a key of a relation is also used to further simplify incremental integrity constraint checking. These incremental integrity constraint checking methods can be implemented easily by Prolog systems.

Extension tables for recursive query evaluation

Abstract: This dissertation presents one of the first top-down demand-driven strategies for the evaluation of recursive queries in logic programs, along with proofs of soundness and completeness. A performance evaluation shows that the strategy performs well in comparison to related methods. The ET* algorithm for evaluating pure logic programs is described. The algorithm uses an extension table to save the results of computations for selected predicates. The ET* algorithm repeatedly evaluates a given query using the extension table until it completes an entire iteration without finding any new answers. A clear and straightforward implementation of the ET* algorithm is developed in Prolog. The dissertation investigates optimizations that may lead to a more efficient evaluation of a logic program using extension tables. These optimizations are supported by performance comparisons. One particular optimization, called the ET algorithm, can be used if a single pass of the ET* algorithm finds all the answers for a given query. In addition to evaluating recursive queries, the ET algorithm is a caching mechanism that can be used to improve the performance of a logic program, when saving and retrieving the results of certain predicates is less expensive than recomputing these answers. In particular, the ET algorithm can be effectively applied to predicates that retrieve tuples from an external relational database management system. This dissertation compares the performance of the top-down demand-driven strategies for recursive query evaluation, including Earley Deduction, Tamaki and Sato's Multistage Depth-first, Vieille's Query/Subquery and Extension Tables. This study shows that the extension table algorithms are, in general, more efficient than the other strategies. The ET* algorithm, which eagerly evaluates a program using all of the answers stored in the extension table, outperforms its iterative recursive counterparts, such as Multistage Depth-first (MSDF) and Query/Subquery (QSQR/SLD), which do not use answers computed on the current iteration. When the ET algorithm finds all the answers for a query, the comparisons indicate that, for such cases, its performance is superior to all its rivals.

A structure-based model of semantic integrity constraints for relational data bases

Abstract: Data base management systems (DBMSs) are in widespread use because of the ease and flexibility with which users access large volumes of data. Ensuring data accuracy through integrity constraints is a central aspect of DBMS use. However, many DBMSs still lack adequate integrity support. In additon, a comprehensive theoretical basis for such support the role of a constraint classification system - has yet to be developed. This paper presents a formalism that classifies semantic integrity constraints based on the structure of the relational model. Integrity constraints are characterized by the portion of the data base structure they access, whether one or more relations, attributes, or tuples. Thus, the model is completely general, allowing the arbitrary specification of any constraint. Examples of each type of constraint are illustrated using a small engineering data base, and various implementation issues are discussed.

An introduction to the nested sequences of tuples data model and algebra

Abstract: A data model based on Nested Sequences of Tuples, called NST, allowing the representation of ordered hierarchical objects and an algebra for object manipulation and restructuring is presented.

Incorporating functional dependencies in deductive query answering

Abstract: We present a set-theoretic interpretation of the relational model which allows a semantic approach to query answering. We show that deduction of new tuples from those in the database is possible through set-containment and we give an algorithm for deductive query-answering.

Formal limits on the automatic generation and maintenance of integrity constraints

Abstract: A formal approach to the automatic generation and maintenance of integrity constraints in relational databases is presented. It is assumed that some portion of the database extension is known and that constraints are to be formed on the basis of this portion. Since this portion may be updated or new relations added to the database the set of hypothesised constraints may require occasional revision. The goal is this paper is to characterise those constraints that may potentially be formed on the basis of a part of the extension. Formal systems are derived by means of which the set of constraints that can be formed is precisely specified. A procedure is derived for restoring the consistency of a set of constraints after conflicting tuples are encountered. It is shown that the set of constraints to which the procedure may be applied corresponds with minor limitations to the sentences of relational algebra.

Derived relations with exceptions

Abstract: Generalization rules are a powerful and versatile tool to represent knowledge at a high level of abstraction--as opposed to conventional data base systems which use data to represent specific facts. A generalization rule used in conjunction with a relational data base system serves two purposes: first, it represents knowledge of a general nature, and second, it defines the subset of a population of tuples that satisfy the conditions defined in the rule. As a generalization, the knowledge being represented does not depend on any specific facts, but rather it describes information of a general nature about an organization or a phenomenon; as a subset of a population, it describes all those individuals that fall into the generalization given by the rule. A major issue that had not been fully addressed in the literature is the problem of exceptions to generalizations. Exceptions arise naturally in the real world because, by definition, a generalization implies a loss of detail, and because even if it were feasible it is probably not desirable nor convenient to define every possible case in a generalization rule. This dissertation has identified the problems in dealing with exceptions, characterized the types of exceptions, analyzed the issues in storing generalization rules and exceptions, studied the possible conflicts in stored data, and proposed definite solutions. These solutions are given in a mathematical, axiomatic form. A mathematical entity called DRE-algebra has been defined that allows the formal specification of generalization rules, exceptions and data base operations on exceptions. In addition, an implementation has been given as an extension to the SQL data base language.

On the Uniqueness of Nested Relations

Abstract: In this paper, we consider two fundamental properties of nested relations: minimum and uniqueness. By nested relations we mean relations over simple and/or set-valued domains. It is shown that the complexity of deciding whether or not a given first normal form relation has a nested form with no more than K tuples is NP-complete. A template dependency is given as an essential integrity constraint to guarantee that a class of first normal form relations has unique nested relations with minimum number of tuples.

Horizontally dividing system for data base

Abstract: PURPOSE: To contrive the equalization of the number of tuples stored in a disk device automatically, by dividing a page into two, when tapple storing pages are full, storing the tuple in one of them, and sending one page to the disk device having the smallest number of pages. CONSTITUTION: It is assumed that a tuple in which key values of an integer value are between 1W100 is stored in a page 3c in a disk device 2e. In case of storing the tuple having a key value of the key values between 1W100, in this page 3c, since the page in full, it is divided into two. Subsequently, the tuple having a key value between 1W50 is stored in the original page 3c, and the tuple having a key value between 51W100 is stored in the other page 3d. A disk 2f is constituted of the tuple of a relation to which its tuple selected in order to store a page 3d belongs, and its number of pages is the smallest. After the page has been divided, a clustered index is reorganized, an operation for determining the disk device to be stored, and the page is repeated, and unless the page is full, the tuple is stored in the determined page. COPYRIGHT: (C)1988,JPO&Japio

Nested relations and recursive queries

Abstract: Recently, several researchers realized that the modelling capabilities of traditional relational data base systems are rather limited for advanced applications. Among others, two main research areas can be identified: One area of research is concerned with removing the limitation of flat tuples by supporting structured objects instead. Another area of research deals with the limitation of traditional query languages. Already in the late seventies it was proven that so called relationally complete query languages do not allow to express the computation of the transitive closure of a relation. Most researchers solve the problem by introducing some kind of recursion. The work presented in this paper is an attempt to combine both areas of research. It proposes the integration of recursive queries and nested relations by providing a recursion mechanism which can be nested according to the structure of a non first normal form relation. It is shown by examples that this method can be used to formulate queries which are rather cumbersome if only flat relations are used. Especially, in some cases the problem of performing a selection on a recursively defined relation disappears. This question has been the topic of several research papers recently. Moreover, many queries can be formulated in a more natural way than in the world of flat tuples. Therefore, nested recursive queries in combination with non first normal form relations provide a contribution to the problem of modelling complex data.

Towards Determining Variable Overlap in Recursive Rule Expansions

Abstract: ONE APPROACH TO THE EVALUATION OF QUERIES AGAINST RELATIONS DEFINED BY A RECURSIVE RULE IS TO DERIVE THE SERIES OF RULES THAT REPRESENT THE RESOLUTION OF MULTIPLE INSTANCES OF THE ORIGINAL RULE, AND APPLY EACH OF THESE DERIVED RULES TO THE BASE SET OF TUPLES THAT ARE IN THE RELATION ``NON-RECURSIVELY''''. WE CALL THESE DERIVED RULES `RULE EXPANSIONS''. A SIGNIFICANT SOURCE OF ECONOMY IN THE EVALUATION IS THE RECOGNITION OF REPEATING PATTERNS OF VARIABLE OVERLAP IN THE LITERALS OF THE RULE EXPANSIONS. IN THIS PAPER WE GIVE CONDITIONS UNDER WHICH THE VARIABLES OF A RULE EXPANSION WILL BE EQUATED IN TERMS OF PATHS OF THE A-GRAPH OF IOANNIDIS. THIS CHARACTERIZATION SHOULD PROVE USEFUL IN DEVELOPING STRATEGIES FOR QUERY EVALUATION.

Grammatical relational database model (w-grammar parser)

Abstract: This work presents a method of verifying normal form constraints on a relational database. Our approach is to formulate the normal forms as a set of Van Wijngaarden grammars (W-grammars). A W-grammar is composed of two sets of rules called Meta-productions and Hyper-rules. Meta-productions are used to generate elements of a relation and then placed in Hyper-rules, thereby creating the rules that verify the static and dynamic semantics of normal forms. The use of where clauses provides the W-grammar with an additional method of enforcing relational database semantics. The formulated normal forms (Qualified, Third and Fourth) into W-grammars are used to enforce static and dynamic semantics through preservation of functional dependencies. Static W-grammar models the attribute level and the relations between attributes. Dynamic W-grammars represent not only the attribute level and the relation between them but also consider the tuples of the relation and the relation of the elements of the tuples to one another. It is useful in the dynamic case to think of the attributes and their relationships forming a program and the tuples forming the data upon which the 'program' operates. Given the appropriate W-grammar, static and dynamic semantics of the normal forms can be verified. The most important results is that for the particular W-grammars considered, parsers may be found that are essentially LR(1) because, by means of a transformation, the original W-grammar with its attendant where clauses is mapped to an LR(1) grammar with an augmented terminal alphabet. The new terminal symbols call for further lexical processing with worst case time complexity of O(n$\sp 3)$ where n is the size of the alphabet. The transformed grammar presents some interesting lexical analysis problems. Their solution requires two types of token recognizers, and the in-string token recognizer and the out-string recognizer. Our investigations may lead to a method which would allow a database administrator to test the correctness of a proposed schema without possessing a deep knowledge of database theory.