Showing papers on "Tuple published in 1997"

On the semantics of “now” in databases

Abstract: Although “now” is expressed in SQL and CURRENT_TIMESTAMP within queries, this value cannot be stored in the database. How ever, this notion of an ever-increasing current-time value has been reflected in some temporal data models by inclusion of database-resident variables, such as “now” “until-changed, ” “**,” “@,” and “-”. Time variables are very desirable, but their used also leads to a new type of database, consisting of tuples with variables, termed a variable database.

Database summarization using fuzzy ISA hierarchies

Abstract: Summary discovery is one of the major components of knowledge discovery in databases, which provides the user with comprehensive information for grasping the essence from a large amount of information in a database. In this paper, we propose an interactive top-down summary discovery process which utilizes fuzzy ISA hierarchies as domain knowledge. We define a generalized tuple as a representational form of a database summary including fuzzy concepts. By virtue of fuzzy ISA hierarchies where fuzzy ISA relationships common in actual domains are naturally expressed, the discovery process comes up with more accurate database summaries. We also present an informativeness measure for distinguishing generalized tuples that delivers much information to users, based on Shannon's information theory.

System and method for caching identification and location information in a computer network

Abstract: Methods and systems are provided for caching information in a distributed computer system such as a directory service system. Tuples in a client cache contain component identifiers and corresponding location identifiers. Tuples may contain a list of network addresses specifying at least one server containing additional location or object information, as well as replica flags which distinguish between read-only replicas, read-write replicas, and a master replica. Requests to access an object may be serviced by using cached information rather than making one or more attempts to obtain location information from servers. Tuples may be modified or invalidated such that read operations tend to be performed using read-only replicas. Cached tuples which contain a component identifier that is no longer valid because an object was moved or renamed may be invalidated. The cache may also be modified to redirect operations from a master replica to a non-master replica.

An operational semantics for ZCCS

Abstract: G. Bruns (1995) has proposed a version of value-passing CCS in which an agent language, based on that proposed by Milner, is augmented with a rich data language. The data language can be used to describe sets, tuples and sequences etc. constructed from integer, Boolean and string constants. Z is a widely used formal specification language in which sets, tuples and sequences can be described, but also additional constructs such as free types and bindings. In addition, Z has a rich structuring mechanism-its schema calculus. Z is frequently used to specify the operations of a system on its state, and has a refinement calculus and formal semantics. This article introduces ZCCS, a version of value-passing CCS in which the data language used to describe the action/agent parameters and conditions is Z. We introduce the style and syntax of ZCCS and illuminate this with a small example. In addition, we present an operational semantics for ZCCS.

BONITA: a set of tuple space primitives for distributed coordination

Abstract: In the last few years the use of distributed structured shared memory paradigms for coordination between parallel processes has become common. One of the most well known implementations of this paradigm is the shared tuple space model (as used in Linda). We describe a new set of primitives for fully distributed coordination of processes and agents using tuple spaces, called the BONITA primitives. The Linda primitives provide synchronous access to tuple spaces, whereas the BONITA primitives provide asynchronous access to tuple spaces. The proposed primitives are able to mimic the Linda primitives, therefore providing the ease of use and expressibility of Linda together with a number of advantages for the coordination of agents or processes in distributed environments. The primitives allow user processes to perform computation concurrently with tuple space accesses, and provide new coordination constructs which lead to more efficient programs. We present the (informal) semantics of the BONITA primitives, a description of how the Linda primitives can be modelled using them and a demonstration of the advantages of the BONITA primitives over the Linda primitives.

Relational database compiled/stored on a memory structure providing improved access through use of redundant representation of data

Abstract: A relational database compiled/stored on a computer environment for storing data about units of work includes a first set of tables and a second set of tables. The first set of tables includes first columns and first tuples and a first dataset containing first data included in the first columns and first tuples. The second set of tables includes second columns and second tuples and a second dataset consisting of second data. The data included in the second columns and second tuples being second data. The units of work including first services, final services and current services. The unit of work having a status being inactive, active or terminated. The second data is a redundant representation of a part of the first data.

An improved algorithm for the incremental recomputation of active relational expressions

Abstract: Qian and Wiederhold (1991) presented an algorithm for the incremental recomputation of relational algebra expressions that was claimed to preserve a certain minimality condition This condition guarantees that the incremental change sets do not contain any unnecessary tuples; so, redundant computations are not performed We show that, in fact, their algorithm violates this condition We present an improved algorithm that does preserve this notion of minimality

System, method, and computer program product for efficiently translating relational tuples to object-oriented objects

Abstract: A procedure for translating tuples received from a relational database management system (RDBMS) to object-oriented objects is described. The procedure operates by instantiating one or more application objects, and then setting base attributes of the application objects using information in the tuples. One or more intermediate objects are created using information in the tuples to represent those application objects having relationship attributes requiring dereferencing. Relationship attributes in the application objects are then set by swizzling the intermediate objects (rather than by swizzling the application objects themselves).

Converting relational to object-oriented databases

Abstract: As object-oriented model becomes the trend of database technology, there is a need to convert relational to object-oriented database system to improve productivity and flexibility. The changeover includes schema translation, data conversion and program conversion. This paper describes a methodology for integrating schema translation and data conversion. Schema translation involves semantic reconstruction and the mapping of relational schema into object-oriented schema. Data conversion involves unloading tuples of relations into sequential files and reloading them into object-oriented classes files. The methodology preserves the constraints of the relational database by mapping the equivalent data dependencies.

Method of calculating tuples for data cubes

Abstract: A method and apparatus of calculating data cubes is shown in which a data set is partitioned into memory sized data fragments and cuboid tuples are calculated from the data fragments A search lattice of the data cube is used as a basis for ordering calculations of lower dimensional cuboids in the data cube Identification of a minimum number of paths through the lattice that is sufficient to traverse all nodes in the lattice is achieved by iteratively duplicating twice all paths in a lower dimensional space, distributing a new attribute to the first duplicate, moving end points from paths of the second duplicate to a corresponding path in the first duplicate and merging the first and second duplicates

Implementing Incremental View Maintenance in Nested Data Models

Abstract: Previous research on materialized views has primarily been in the context of flat relational databases—materialized views defined in terms of one or more flat relations. This paper discusses a broader class of view definitions-materialized views defined over a nested data model such as the nested relational model or an object-oriented data model. An attribute of a tuple deriving the view can be a reference (i.e., a pointer) to a nested relation, with arbitrary levels of nesting possible. The extended capability of this nested data model, together with materialized views, simplifies data modeling and gives more flexibility.

Constraint query algebras

Abstract: Constraint databases are an extension of relational databases. A framework for the constraint data model, constraint query semantics and their declarative specification (constraint calculi) was formulated by Kanellakis, Kuper, and Revesz in 1990. Constraint query algebras (CQAs) form a procedural language layer of constraint databases, underneath high-level declarative calculi; this layer is the appropriate setting for approaching the issues of constraint query optimization and implementation. This work represents the first extensive study of CQA's. We define the semantics of CQA queries via the closure principle, and highlight the importance of CQA data representation, and its desirable properties. We use the example of dense order constraint algebra to show how an appropriate canonical form of constraint tuples can affect the implementation of a CQA. For monotone two-variable linear constraint algebra, we propose to modify the variable elimination algorithm used for computing projections, via pruning, leading to an implementation of projection that is strongly polynomial. We also introduce a notion of variable independence as a restriction on constraint relational schema, and show how it ensures the closure of CQA+aggregation. Multidimensional indexing structures are expected to play an important role in implementing and optimizing CQA's. We illustrate the feasibility of using a multidimensional indexing structure as a back end in querying mechanisms with our implementation of similarity querying far time-series data, a previously unsolved problem. Finally, we consider some possible directions in CQA query optimization. When evaluating queries over (non)linear constraints, we propose to avoid costly symbolic processing with the lazy evaluation of (non)linear constraint algebras. When estimating the cost of different evaluation strategies for CQA expressions, we suggest to use the indexing information for the relation's attributes.

Three-dimensional affine-invariant hashing defined over any three-dimensional convex domain and producing uniformly-distributed hash keys

Abstract: A uniform distribution of affine invariants (3-tuples) is produced for a plurality of one or more three-dimensional objects. Each of the three-dimensional objects, capable of a plurality of affine transformations, is defined by a set of object points (feature points) selected from an object feature domain. By selecting one or more five-point tuples of the object points, four of the object points divide the object feature domain into a region arrangement of fifteen regions while the fifth point of the five-point tuple lies in one of the fifteen regions and each of the five-point tuples further defines each of the fifteen regions as one of five reentrant polyhedral (RP) arrangements or one of ten non-reentrant polyhedral (NRP) arrangements. A five-point tuple is said to belong to class i if the fifth point of the tuple resides in the i-th of the 15 regions defined by the first four points. A tagger identifies each of the five-point tuples as having one of the arrangements with one of the regions containing the fifth point of the five-point-tuple. During a knowledge accumulation mode, and using either synthetically generated (Monte-Carlo simulation) or real data, an equalizer accumulates knowledge about occupancy patterns incurred by five-point tuples belonging to each of the 15 classes and then derives the necessary remappings that will result in an expected uniform distribution over the range of invariants for all produced invariants. After the knowledge accumulation phase, the equalizer enters its redistribution mode the end-product of which is the creation of a new distribution of affine invariants (3-tuples) that is uniform over the range of invariants. A stacker then stacks the remapped regions to create a complete uniform distribution for all the affine invariants that the transformer produces. The system produces a table which associates combinations of object points (five-point tuples) to affine invariants (3-tuples); the table can be used as the core of an indexing-based store and retrieve system, it can be used to determine and identify over-represented constructs of object points, to determine potential interaction for ligand-receptor complexes, etc.

Manipulating Spatial Data in Constraint Databases

Abstract: Constraint databases have recently been proposed as a powerful framework to model and retrieve spatial data. In a constraint database, a spatial object is represented as a quantifier free conjunction of (usually linear) constraints, called generalized tuple. The set of solutions of such quantifier free formula represents the set of points belonging to the extension of the object. The relational algebra can be easily extended to deal with generalized relations. However, such algebra has some limitations when it is used for modeling spatial data. First of all, there is no explicit way to deal with the set of points representing a spatial object as a whole. Rather, only point-based computations can be performed using this algebra. Second, practical constraint database languages typically use linear constraints. This allows to use efficient algorithms but, at the same time, some interesting queries cannot be represented (for example, the distance between two objects cannot be computed). Finally, no update language for spatial constraint databases has been defined yet. The aim of this paper is to overcome some of the previous limitations. In particular, we extend the model and the algebra to directly deal with the set of points represented by a generalized tuple (a spatial object), retaining at the same time the ability of expressing all computations that can be expressed by other constraint database languages. Moreover, we discuss the introduction of external functions in the proposed algebra, in order to cover all the functionalities that cannot be expressed in the chosen logical theory. Finally, we propose an update language for spatial constraint databases, based on the same principles of the algebra.

The expressive power of temporal relational query languages

Abstract: The authors consider the representation of temporal data based on tuple and attribute timestamping. They identify the requirements in modeling temporal data and elaborate on their implications in the expressive power of temporal query languages. They introduce a temporal relational data model where N1NF relations and attribute timestamping are used and one level of nesting is allowed. For this model, a nested relational tuple calculus (NTC) is defined. They follow a comparative approach in evaluating the expressive power of temporal query languages, using NTC as a metric and comparing it with the existing temporal query languages. They prove that NTC subsumes the expressive power of these query languages. They also demonstrate how various temporal relational models can be obtained from the temporal relations by NTC and give equivalent NTC expressions for their languages. Furthermore, they show the equivalence of intervals and temporal elements (sets) as timestamps in their model.

Locality Based Linda: Programming with Explicit Localities

Abstract: In this paper we investigate the issue of defining a programming calculus which supports programming with explicit localities. We introduce a language which embeds the asynchronous Linda communication paradigm extended with explicit localities in a process calculus. We consider multiple tuple spaces that are distributed over a collections of sites and use localities to distribute/retrieve tuples and processes over/from these sites. The operational semantics of the language turns out to be useful for discussing the language design, e.g. the effects of scoping disciplines over mobile agents which maintain their connections to the located tuple spaces while moving along sites. The flexibility of the language is illustrated by a few examples.

A tool for organizing Web information

Abstract: The physical and logical differences among information sources on the Internet complicate information retrieval. For instance, data is no longer just simple text or tuples, but now includes objects and multimedia. Data can also have varied and often arcane semantics. Sources have different policies, procedures, and conventions and are hosted by diverse platforms. Ontologies-models of concepts and their relationships-are a powerful way to organize query formulation and semantic reconciliation in large distributed information environments. They can capture both the structure and semantics of information environments, so an ontology-based search engine can handle both simple keyword-based queries as well as complex queries on structured data. Ontology-based interoperation is especially good at dealing with inconsistent semantics. However; ontologies are difficult to construct. The Java Ontology Editor (JOE) helps users build and browse ontologies. It also enables query formulation at several levels of abstraction. The authors discuss the use of JOE to develop a health care information system.

Automatic programming of cellular automata: identification approach

Abstract: To program cellular automata is to define cell neighbourhood and cell‐state transition rules in order to design an automation which exhibits determined patterns in its evolution or which transforms a given image into another image. In general, a tool for the automatic programming of cellular automata should translate the tuple (source‐configuration) → (target‐configuration) into a set of cell‐state transition rules. This is a problem which has not been completely solved yet. Attempts to show examples of automatic programming of cellular automata using identification algorithms. Results obtained can be used in the design of massively parallel processors with cellular‐automata architecture and a conventional, as well as non‐traditional (e.g. molecular and chemical), elementary base.

Quality of Service Support in a Mobile Environment: An Approach Based on Tuple Spaces

Abstract: There has recently been considerable interest in quality of service management architectures for high speed networks. In contrast, however, there has been less research on appropriate architectures for mobile computing. This paper addresses the issue of quality of service in a mobile environment. In particular, we describe a distributed systems platform, Limbo, which is intended to support the development of demanding, mobile-aware distributed applications in a heterogeneous networking environment. This platform is based on the concept of tuple spaces and is extended with support for quality of service management. The emphasis of quality of service management is on monitoring and adaptation, although support is also provided for other functions such as admission control and resource reservation. The paper argues that there are significant benefits from using a tuple space paradigm in such an environment, particularly in terms of the ability to adapt to changes in network connectivity or the more general environment.

Asserting beliefs in MLS relational models

Abstract: Multilevel relations, based on the current multilevel secure (MLS) relational data models, can present a user with information that is difficult to interpret and may display an inconsistent outlook about the views of other users. Such ambiguity is due to the lack of a comprehensive method for asserting and interpreting beliefs about lower level information. In this paper we identify different beliefs that can be held by higher level users about lower level information, and we introduce the new concept of a mirage tuple. We present a mechanism for asserting beliefs about all accessible tuples, including lower level tuples. This mechanism provides every user of an MLS database with an unambiguous interpretation of all viewable information and presents a consistent account of the views at all levels below the user's level.

Learning maximal generalized decision rules via discretization, generalization and rough set feature selection

Abstract: We present a method to mine maximal generalized decision rules from databases by integrating discretization, generalization and rough sets feature selection. Our method reduces the data horizontally and vertically. In the first phase, discretization and generalization are integrated and the numeric attributes are discretized into a few intervals. Primitive values of symbolic attributes are replaced by high level concepts and some obvious superfluous or irrelevant symbolic attributes are also eliminated. Horizontal reduction is accomplished by merging identical tuples after the substitution of an attribute value by its higher level value in a predefined concept hierarchy for symbolic attributes or the discretization of continuous (or numeric) attributes. In the second phase, a novel context sensitive feature merit measure is used to rank the features, a subset of relevant attributes is chosen based on rough sets theory and the merit values of the features. A reduced table is obtained by removing those attributes which are not in the relevant attributes subset and the data set is further reduced vertically without destroying the interdependence relationships between the classes and the attributes. Rough sets based value reduction is further performed on the reduced table and all redundant condition values are dropped, finally, tuples in the reduced table are transformed into a set of maximal generalized decision rules. The experimental results on UCI data sets and an actual market database shows that our method can dramatically reduce the feature space and improve the learning accuracy.

Query optimization through the use of multi-column statistics to avoid the problems of column correlation

Abstract: The system, method, and program of this invention collects multi-column statistics, by a database management system, to reflect a relationship among multiple columns of a table in a relational database. These statistics are stored in the system catalog, and are used during query optimization to obtain an estimate of the number of qualifying rows when a query has predicates on multiple columns of a table. A multi-column linear quantile statistic is collected by dividing the data of multiple columns into sub-ranges where each sub-range has approximately an even distribution of data, and determining a frequency and cardinality of each sub-range. A multi-column polygonal quantile statistic is collected by dividing the data of multiple columns into sub-spaces where each sub-space contains approximately the same number of tuples, and determining a frequency and cardinality of each sub-space. The system catalog is accessed for the stored multi-column linear quantile statistic for a query having a single range predicate and at least one equal predicate to determine the selectivity value for the predicates of the query. The system catalog is accessed for the stored multi-column polygonal quantile statistic for a query having more than one range predicate. These statistics are used in various ways to determine the selectivity value for the predicates of the query.

Compositional references for stateful functional programming

Abstract: We introduce the notion of compositional references into the framework of monadic functional programming and propose a set of new primitives based on this notion. They enable us to use a wide range of mutable data structures. There, references may be passed around explicitly, or mutable data structures such as arrays and tuples may be passed implicitly as hidden state. The former style is called the explicit style and is usually more expressive, while the latter is called the implicit style and has simpler semantics. We investigate the relation between the two styles and discus implementation issues.

Functional dependencies revisited under graduality and imprecision

Abstract: In the database area, the notion of data property has been recognized for two main purposes: data control when the property is a constraint; and knowledge discovery when the property is the result of a mining process. Among the properties, functional dependencies (FD) have received special attention for many years, since they are connected with database design. Different extensions of functional dependencies have been proposed but the semantics sometimes remains obscure. This paper discusses the semantics of basic extensions of a functional dependency when fuzzy sets (and/or possibility) theory is used. The case of a relational database where tuples may contain imperfectly known values is specifically investigated.

Designing the reengineering service for the DOK federated database system

Abstract: Addresses the design of the reengineering service for the DOK (Distributed Object Kernel) federated database. This service allows the hiding of the heterogeneity of databases involved in a federation by generating object-oriented representations from their corresponding schemata. We propose a complete methodology that supports the identification and the translation of both the explicit and implicit information. The identification of object-oriented constructs is performed by classifying a relational schema into different categories of relations, namely base, dependent and composite relations. The main difficulty in designing the reengineering service relies on the distinction between the different types of relationships amongst classes. Our approach deals with this problem by analysing relations according two types of correlation: (i) the degree of correlation between the external and primary keys, and (ii) the degree of correlation between sets of tuples in the relations. Examining these correlations uncovers implicit relationships contained as well-hidden classes in a relational schema.