Showing papers on "Graph database published in 1989"

A model of queries for object-oriented databases

Abstract: One major source of confusion, and consequent c&icisms, about object-oriented databases has been the lack of a comprehensive model of queries. Although there is a reasonable degree of agreement about an object-oriented data model, few operational systems support a query model for object-oriented databases. In this paper, we present a rather comprehensive query model which is consistent with object-oriented concepts embodied in the object-oriented data model. The model takes into account the semantics of the class hierarchy and nested objects, and as such is inherently richer than the relational or nested relational model of queries. A significant subset of the model has been cast into a query language which is supported in the ORION object-oriented database system.

KDA: a knowledge-based database assistant

Abstract: A knowledge-based database assistant, KDA, is described that has a query-guide function, an SQL-like database query generator, and an interface for subset-English. KDA can be used to design the front end of an SQL database system or a computer-based SQL tutorial system. A method is discussed for transforming a semantic network representing a user's conceptual query into one providing the information required by the system to respond to a query. The query pattern is an expression in natural language representing the semantic structure of concepts. The user expresses queries by filling parentheses in the query patterns with appropriate words. The query-pattern instances thus obtained are then translated into SQL-like relational database queries. The translation is carried out by evaluating operations defined on a semantic network named G-Net which conveys knowledge about application fields, the database schema, and the syntax of SQL. >

Finding regular simple paths in graph databases

Abstract: We consider the following problem: given a labelled directed graph G and a regular expression R, find all pairs of nodes connected by a simple path such that the concatenation of the labels along the path satisfies R. The problem is motivated by the observation that many recursive queries can be expressed in this form, and by the implementation of a query language, G+, based on this observation. We show that the problem is in general intractable, but present an algorithm than runs in polynomial time in the size of the graph when the regular expression and the graph are free of conflicts. We also present a class of languages whose expressions can always be evaluated in time polynomial in the size of both the database and the expression, and characterize syntactically the expressions for such languages.

Generating aspect graphs for curved objects

Abstract: The authors present an algorithm for computing the aspect graph of a curved object. The approach used to partition the viewpoint space is to compute boundary viewpoints from the shape descriptions of an object in a CAD database. These computations are formulated from the understanding of visual events and the locations of corresponding viewpoints. Also presented is a study of new visual events for piecewise smooth objects. >

Improving list comprehension database queries

Abstract: The improvement of queries expressed as list comprehensions in a lazy functional language is described. The database literature identifies four algebraic and two implementation-based improvement strategies. For each strategy the authors show an equivalent improvement for queries expressed as list comprehensions. This means that well-developed database algorithms that improve queries using several of these strategies can be emulated to improve comprehension queries. They are also able to improve queries which require greater power than that provided by the relational algebra. Most of the improvements entail transforming a simple, inefficient query into a more complex, but more efficient form. The authors illustrate each improvement using examples drawn from the database literature. >

Graph reduction without pointers

Abstract: Graph reduction is one way to overcome the exponential space blow-ups that simple normal-order evaluation of the lambda-calculus is likely to suffer. The lambda-calculus underlies lazy functional programming languages, which offer hope for improved programmer productivity based on stronger mathematical underpinnings. Because functional languages seem well-suited to highly-parallel machine implementations, graph reduction is often chosen as the basis for these machines' designs. Inherent to graph reduction is a commonly-accessible store holding nodes referenced through "pointers," unique global identifiers; graph operations cannot guarantee that nodes directly connected in the graph will be in nearby store locations. This absence of locality is inimical to parallel computers, which prefer isolated pieces of hardware working on self-contained parts of a program. In this dissertation, I develop an alternate reduction system using "suspensions" (delayed substitutions), with terms represented as trees and variables by their binding indices (de Bruijn numbers). Global pointers do not exist and all operations, except searching for redexes, are entirely local. The system is provably equivalent to graph reduction, step for step. I show that if this kind of interpreter is implemented on a highly-parallel machine with a locality-preserving, linear program representation and fast scan primitives (an FFP Machine is an appropriate architecture) then the interpreter's worst-case space complexity is the same as that of a graph reducer (that is, equivalent sharing), and its time complexity falls short on only one unimportant case. On the other side of the ledger, graph operations that involve chaining through many pointers are often replaced with a single associative-matching operation. What is more, this system has no difficulty with free variables in redexes and is good for reduction to full beta-normal form. These results suggest that non-naive tree reduction is an approach to supporting functional programming that a parallel-computer architect should not overlook.

RINDA - A Relational Database Processor for Non-Indexed Queries.

Abstract: A new relational database processor called RINDA is presented. RINDA performs key database operations, such as search and sort, at very high speed with specialized hardware. It is attached to general purpose computers and controlled by database management software. In this paper, the architecture of RINDA is described from the viewpoint of hardware and Software. PerfOrIUanCe evaluation shows RINDA accelerates non-indexed queries of relational databases by 10 to 100 times compared with conventional database management software.

A Graph Based Data Structure for Efficient Implementation of Main Memory DBMS's

Abstract: Considering that in future DBMS's it will be possible to hold the active database in main memory, a new physical database organization is proposed. This organization aims two objectives: be compact and decomposable such as the active database always fits in main memory and speed up extended relational algebra in term of CPU time. Tuples and indices are integrated in a unique data structure called DBGraph. Tuples and values are stored separately and constitute the vertices of the DBGraph. Edges between tuples and values are maintained using OID's in order to constitute a bipartite graph. This graph precompiles selection, join and transitive closure operations. Set oriented execution of relational algebra is generated using a breadth first traversal of this graph while pipeline execution is produced using a depth first traversal. The two strategies lead to the same temporal complexity. Storage cost evaluations demonstrate the compactness of the DBGraph structure. Performance evaluations show that in a main memory context transitive closure on DBGraph outperforms transitive closure on join indices, still considered as one of the best algorithm.