Showing papers on "Tuple published in 1984"

A class of data structures for associative searching

Abstract: By interleaving the bits of the binary representations of the attribute values in a tuple, an integer corresponding to the tuple is created. A set of these integers represents a relation. The usual ordering of these integers corresponds to an ordering of multidimensional data that allows the use of conventional file organizations, such as Btrees, in the efficient processing of multidimensional queries (e.g. range queries). The class of data structures generated by this scheme includes a type of kd tree whose balance can be efficiently maintained, a multidimensional Btree which is simpler than previously proposed generalizations, and some previously reported data structures for range searching. All of the data structures in this class also support the efficient implementation of the set operations.

Accurate estimation of the number of tuples satisfying a condition

Abstract: We present a new method for estimating the number of tuples satisfying a condition of the type attribute rel constant, where rel is one of "=", ">", "

Updates of Relational Views

Abstract: The problem of translating updates of database views is studied. View updates are disambi- guated by requiring that a specified view complement (i.e., a second view that contains all the information omitted from the given view) remain constant during the translation. Some of the computational problems related to the apphcafion of this general methodology in the context of relational databases are studied. Projective views of databases that consist of a single relation and satisfy funcuonal dependencies are emphasized. After characterizing complementary views, the authors show that finding a minimum complement of a given view is NP-complete. The problem of translating the insertion of a tuple into a view is then studied in detail, and the results are extended to the cases of deletion and replacement of a tuple. Finally, the explicit functional dependencies, a new kind of dependency that intuitively states that some part of the database information can be computed from the rest, are defined and studied.

Molecular Objects, Abstract Data Types, and Data Models: A Framework

Abstract: Molecular objects occur frequently in CAD and engineering applications At higher levels of abstraction they are treated as atomic unit,s of data; at lower levels they are defined in terms of a set of tuples possibly from different relations System R’s complex objects are examples of molecular objects In this paper, we present a framework for studying a generalized concept of molecular objects We show that abstract data types unify this framework, which itself encompasses some recent data modeling contributions by researchers at IBM San Jose, Berkeley, Boeing, and Florida A programming language/data structure paradigm is seen as a way of developing and testing the power of logical data models A primary consequence of this paradigm is that future DBMSs must handle at least four distinct types of molecular objects: disjoint/non-disjoint and recursive/nonrecursive No existing DBMS presently supports all these types

Formal Systems for Tuple and Equality Generating Dependencies

Abstract: We develop several formal systems for tuple and equality generating dependencies. There are three kinds of systems, based upon substitution, tuple elimination and transitivity. We specialize our systems to several subclasses: total dependencies, template dependencies and binary dependencies. We also show that finding a formal system for embedded multivalued dependencies is equivalent to solving the implication problem for that class.

Maintenance of views

Abstract: In relational databases a view definition is a query against the database, and a view materialization is the result of applying the view definition to the current database A view materialization over a database may change as relations in the database undergo modificationsIn this paper a mechanism is proposed in which the view is materialized at all times The problem which this mechanism addresses is how to quickly update the view in response to database changes A structure is maintained which provides information useful in minimizing the amount of work caused by updatesMethods are presented for handling both general databases and the much simpler tree databases (also called acyclic database) In both cases adding or deleting a tuple can be performed in polynomial time For tree databases the degree of the polynomial is independent of the schema structure while for cyclic databases the degree depends on the schema structure The cost of a sequence of tuple additions (deletions) is also analyzed

Measurements of program similarity in identical task environments

Abstract: This paper summarizes the results of a study which compared the efficiency of two methods of measuring program similarity in the context of novice programmers trying to reach identical objectives. Both methods look for similarity by comparing 'program profiles'. Such profiles are created by feature extraction routines which map each program onto a tuple where each fi is a count of an occurrence of a particular feature. A comparison routine is then invoked which detects similarities between tuples. The results showed that in this environment the comparison routine based on the Halstead metric failed to perform as well as a conceptually simpler alternative.

Stream processing

Abstract: Stream processing is a basic method of code optimization related to loop fusion that can improve the space and speed of iterative applicative expressions by a process of loop combination. It has been studied before in applications to program improvement and batch oriented database restructuring. Previous attempts at implementation have been either highly restrictive, have required manual intervention, or have involved naive strategies resulting in impractically slow running times.This paper defines a new model for a stream processing problem for handling a wide class of applicative expressions that can be evaluated by looping in an unordered way through a single set or tuple valued argument. This problem is formulated graph theoretically and shown to be NP-Hard, even in the presence of constraints. Two new efficient heuristic algorithms will be presented. The efficiency of these solutions allows stream processing to be applied dynamically as a database query optimization, and as an important component of a high level language optimizer.Our method of stream processing has been implemented and used effectively within the RAPTS transformational programming system.

Method of developing formal identities and program bases in an optimizing compiler

Abstract: A method operable within an optimizing compiler for generating Basis items and Kill Sets for use during subsequent global common subexpressions elimination and code motion procedures. More particularly, the method comprises assigning a symbolic register to each non-basis element to be computed as follows: creating a tuple (v) for each computation which is to be converted to a machine instruction by the compiler creating a table (optimally, a hash table) having an entry for all the tuples in the program being compiled; for every Basis element in a tuple being entered in the table a symbolic register uniquely assigned to that tuple is added to the Kill Set for that Basis element. For every non-basis element "n" in the tuple being entered into the table, the uniquely assigned symbolic register for that tuple is added to the Kill Sets for all the Basis elements in whose Kill Sets that non-basis element "n" appears. The symbolic register assigned to the tuple in the table is chosen to total the result of the computation of the non-basis element; and finally, a second table is constructed so that given a symbolic register, the computation which it represents can be retrieved.

Accurate estimation of the number of tuples satisfying a condition

Abstract: We present a new method for estimating the number of tuples satisfying a condition of the type attribute rel constant, where rel is one of "=", ">", "<", "", "". Our method gives highly accurate, y...

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

Spectral inclusion for subnormal $n$-tuples

Abstract: Let S be a subnormal operator on a Hubert space and let N be its minimal extension. Then a celebrated theorem due to P. Halmos asserts that Sp(/V) C Sp(5), denoting by Sp the spectrum. This note contains a multidimensional version, with respect to Taylor's joint spectrum, of this spectral inclusion theorem. Recently R. Curto [1] has extended Halmos' spectral inclusion theorem for subnormal operators to the case of n-tuples of doubly commuting subnormal operators. In this note we improve Curto's result by removing the double commutativity assumption. Let S = (S,,... ,S„) be a subnormal n-tuple of commuting operators on a Hilbert space % (i.e. there exists a commuting n-tuple of normal operators which extends S). Then there exists a unique, up to isometric isomorphism, minimal extension of S. Let Sp(5, DC) denote Taylor's joint spectrum of S on DC. Theorem. Let S be a commuting subnormal n-tuple on DC and let N be its minimal normal extension to a Hilbert space %. Then Sp(N,%) CSp(S,%). Proof. It is enough to prove that 0 £ Sp(S, DC) implies 0 £ Sp(JV, DC), or equivalently, by a Gelfand transformation argument, that 0 £ Sp(|./V|, DC)» where \N\2 = y=iN,N*. Suppose 0 £ Sp(S, DC). Then the operator S: DC" -* DC is onto, and after a homothety, one can suppose that n (V)/i G DC, (3)/.»,...,»„ G DC such that 2 S,h, = h, (1) and 2ll«,ll2^ll«ll2i=i Take the spectral measure E of N and let £ be the space £({z||z|< l/2n})DC, which reduces the operators N¡. If we prove that £ ± %, then, by the minimality of the extension N, £ must be 0, hence | N \ will be invertible. Received by the editors December 17, 1982. 1980 Mathematics Subject Classification. Primary 47B20; Secondary 47A10, 47D99.

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.

On relational algebra with marked nulls preliminary version

Abstract: We formulate some natural conditions which should be satisfied in an extension of the relational algebra from the usual relations to tables with null values, and we explain the motivation behind these conditions. Roughly speaking, our conditions say that the extended algebra makes it possible to correctly compute the "true tuples" in the result of applying a relational expression (query) to tables with nulls (database state), and that the computation can be carried out recursively, following the structure of the expression. We prove that these conditions are exactly equivalent to other conditions proposed earlier by the author and T. Imielinski. We give a simple proof of the correctness of the "naive" extension of the relational algebra to tables with marked nulls, where the nulls are treated as if they were regular values, and which supports the operations of projection, positive selection, union, join and renaming of attributes. We also show that the result of the naive evaluation of such an expression (query) is equal to the response to the query as defined --- in a proof-theoretic framework --- by Reiter.

The complexity of evaluating relational queries

Abstract: A sequence of results which characterize exactly the complexity of problems related to the evaluation of relational queries consisting of projections and natural joins is proved. It is shown that testing whether the result of a given query on a given relation equals some other given relation is D p -complete ( D p is the class of languages that are equal to the intersection of a language in NP and a language in co- NP —it includes both NP and co- NP , and was recently introduced in a totally different context, see Papadimitriou and Yannakakis, 1982 , Proceedings, 14th Annual ACM Sympos. on the Theory of Computing, San Francisco, Calif., pp. 255–260). It is shown that testing inclusion or equivalence of queries with respect to a fixed relation (or of relations with respect to a fixed query) is Π p 2 -complete. The complexity of estimating the number of tuples of the answer is also examined.

Functional behavior of nondeterministic and concurrent programs

Abstract: The functions behavior of a deterministic program segment is a function f:D→D, where D is some set of states for the computation. This notion of functional behavior can be extended to nondeterministic and concurrent programs using techniques from linear algebra. In particular, the functional behavior of a nondeterministic program segment is a linear transformation f:A→A, where A is a free semiring module. Other notions from linear algebra carry over into this setting. For example, weakest preconditions and predicate transformers correspond to well-studied concepts in linear algebra. Using multilinear algebra, programs with tuples of inputs and outputs can be handled. For nondeterministic concurrent programs, the functional behavior is a linear transformation f:A→A, where A is a free semiring algebra. In this case, f may also be an algebra morphism, which indicates that the program involves no interprocess communication. Finally, a model of syntax for programs is studied whose semantics is given using linear algebra. It is shown that in this model, free interpretations (essentially Herbrand universes) do not generally exist.

Combining relational and network retrieval methods

Abstract: New methods for retrieving records from a database with links are given so that records are retrieved only once and not multiple times as happens when using the traditional method of retrieval Improvements as great as 50 percent are expected for queries over databases containing only many-to-one relationships and much greater improvements are expected when many-to-many relationships are embedded in the database Furthermore, it is shown how to combine relational and network retrieval methods Relations, containing many tuples, are created during the evaluation of a network query Each relation is either joined with other relations or is used to continue the evaluation of the network query The methods given show how to optimize data retrieval from a relational database that is implemented using links, where each link represents a many-to-one relationship

The Logical Basis for Computer Programming : Deductive Reasoning

Abstract: An introduction to the basic notions of propositional and predicate logic and special theories including integers, strings, trees, lists, sets, and tuples (arrays). Algorithms are expressed not as explicit programs but as the definitions of functions and relations within these theories

A parallel pipelined relational query processor: An architectural overview

Abstract: This paper outlines the overall architecture of a query processor for relational queries and describes the design and control of its major processing modules. The query processor consists of only four processing modules and a number of random-access memory modules. Each processing module processes tuples of relations in a bit-serial, tuple-parallel manner for each of the primitive database operations which comprise a complex relational query. The query processor is designed to be manufacturable using existing VLSI technology, and to support in a uniform manner both the numeric and nonnumeric processing requirements a high-level query language like SQL presents.

Physical record clustering in databases

Abstract: The NP‐complete problem of optimally placing tuples on a hierarchy of secondary storage devices is considered using a heuristic approach. From load specification details captured at database design time, those tuples associated with queries which merit tailored, “set‐in‐concrete”, physical access paths are placed using a two‐level graph partitioning algorithm. Experiments are reported with the pages and cylinders as the two hierarchical levels of storage for a centralised database, but the technique is applicable to an n‐Ievel storage hierarchy—as up to the “different sites” level for distributed databases. The results show up to 39% improvement over single‐level partitioning algorithms for the database considered.

A methodology for benchmarking relational database machines

Abstract: The thesis presents a methodology for benchmarking relational database machines. The methodology is based on a three-level hierarchy of models. At the lowest level is the machine model. The machine is modeled as a high-level language architecture, i.e., as a machine which executes a relational query language. The next level in the hierarchy is the database model. The database is modeled as a synthetic database consisting of twelve relations of varying tuple width and cardinality. The relations are based on a standard tuple template. The highest level in the hierarchy is the applications model. We present two applications models. The first applications model consists of a collection of basic benchmarks. The idea of the basic benchmarks is to measure the best-case performance of the machine in single-user mode. Detailed specifications are given for twenty-five basic benchmarks. A general procedure for analyzing the measurements is supplemented by the detailed instructions given with each benchmark specification. The analysis of the basic benchmark measurements results in a classification of the benchmark queries. The classification scheme is based on the resources used in execution. There are three classes of queries: access-intensive, processor-intensive, and overhead-intensive. Three simple performance indices, one for each classification, are developed to express the performance of the machine for each of these query classes. The classification of queries and the performance indices from the basic benchmarks are used to develop the second applications model, a multiple-user benchmark model. The idea of the multiple-user benchmarks is to compare the performance of the machine with multiple users to the best-case performance measured in the basic benchmarks. Experiments in an application of the methodology are reported. Nine of the basic benchmarks are included in the experiments. The results show that the methodology provides useful information about the performance of the benchmarked machine. The calculation of the performance indices and of the construction of standard jobs for multiple-user benchmarks are illustrated using the measurements collected in these experiments.

Distributed query optimization: An engineering approach

Abstract: We present a novel preprocessing technique for distributed query optimization which achieves nearly all of the benefits that full database reduction by semijoin achieves, but for a small fraction of the cost. Most previous researchers have approached the problem of distributed query optimization with the idea of achieving maximum database reduction at any cost. We take an engineering approach — that, past a point of diminishing returns, database reduction is not cost-effective. We introduce a technique called "partial reduction", which uses a sequence of "bucket semijoins" to eliminate nearly all of the irrelevant tuples eliminated by a fully reducing sequence of semijoins. We provide a performance analysis for a simple binary semijoin compared to a bucket semijoin, and show that a bucket semijoin can achieve, say, 90% of the reduction that a semijoin can, but for, say, 10% of the cost. Although we used some simplifying assumptions in our analysis, we argue that relaxing these assumptions does not diminish our results in any way. We discuss the sensitivity of our technique to its parameters, and we show that our results improve for multiple join and inequality join queries.

A generalized method for maintaining views

Abstract: A generalized method for maintaining views, which takes into account each view's pattern of usage, is described. This method involves storing views in both actual and potential forms. When views exist in actual form (concrete views), updates are deferred until the view is queried. Differential files are formed from tuples inserted and deleted from the defining relations. These differential files are then used in conjunction with specified update schemes to update the view. Views alternate between actual and potential form based on their usage and the storage replacement algorithm.

Predicate trees: An approach to optimize relational query operations

Abstract: With the advent of relational database systems, multi-key searching problems have became the focus of a great deal of research. In this paper, we present a new data structure called predicate trees for clustering tuples of a relation in a way that allows the system to accelerate a large number of multi-dimensional queries. The directories used for the implementation of predicate trees in SABRE are organized as relations which are searched efficiently by filters. One of the most significant advantages of predicate trees is the possibility of defining logical addresses based on content, called signatures, and to use filters to manage directories.

Low level structures in the implementation of the relational algebra

Abstract: We present storage organization schemes and a tuple density model of a relation, for the efficient processing of information in a relational database. The underlying concept used in the design of the storage schemes and the density model is that of a multidimensional array. These organizational schemes are: Multidimensional Paging, Dynamic Multipaging, and two dynamic multidimensional hashing schemes, DMHL and DMHE. The DMHL and DMHE schemes are the respective extensions of linear hashing and extendible hashing for multidimensional data organization. Storage mapping functions for extendible arrays are developed as the page addressing functions in the dynamic multidimensional structures. Performance of the multipaging schemes are examined through empirical studies. We show how relations are structured with these organizational methods to provide symmetric access to the data on any combination of attributes. Further we derive size estimation formulae for the result of the various relational operations using the density model.