Showing papers on "Graph database published in 1993"

Graphical display of data

Abstract: A method of using a computer system 20 to implement a graphical interface 10. The method displays a graph 160 of data from a database system 11, and permits a user to change the data by changing the appearance of the graph 160. The graph 160 is generated from a stored graphics engine 12, which contains rules for generating graphical objects comprising the graph and the objects' attributes. The graphical objects and attributes are matched to data delivered from the database system 11. If the user manipulates a graphical object, the graphical interface 10 associates the change to a new data value, and updates both the graph 160 and the data in the database system 11.

Aggregation in Constraint Databases.

Abstract: We discuss the issues that arise when we add aggregation to a constraint database query language. One example of the use of ag-gregation in such a context is to compute the area of a region in a geographic database. We show how aggregation could be added to the query language, tuple calculus, and discuss the problems that arise from the interaction of aggregate operators and constraints.

Construction of a relational front-end for object-oriented database systems

Abstract: Proposes a solution for the construction of a relational front-end for object-oriented database systems (OODBs). Rules are provided to transform the structural part of an OODB scheme to an equivalent relational scheme to provide relational users with a relational view of the OODB scheme. A mechanism based on a relational predicate graph and an OODB predicate graph is provided to translate relational queries to OODB queries to allow relational users access to data stored in an OODB database system. >

GOOD: a graph-oriented object database system

Abstract: In this video session we demonstrate a graph oriented database management system called GOOD The scheme of a database is represented as a directed graph Also the database instance is conceptually represented as a graph However such an instance graph contains all information stored in the database and is therefore too complicated to be displayed completely on the computer screen in a user friendly way It would be almost impossible to nd the desired information not to men tion how di cult it would be to make directly changes in such a graph Therefore we devel oped a language that simpli es the information retrieval and modi cation

Similarity retrieval of NOAA satellite imagery by graph matching

Abstract: An attributed relational graph (ARG) is introduced into our NOAA satellite image database system. The node and the branch of an ARG denotes a classified region and a spatial relationship between adjacent regions, respectively. Furthermore, a few attributes of a node/branch help to express numerical shape features of regions. Similarity retrieval thereby turns out to be equivalent to graph matching. The similarity retrieval process of the system is as follows: (1) select a visual example image as a query and generate its graph structure, (2) calculate an optimal graph matching cost between a query graph and an archived graph in the database, utilizing algorithm A* with heuristic information, (3) choose archived images in the ascending order of a corresponding matching cost.© (1993) COPYRIGHT SPIE--The International Society for Optical Engineering. Downloading of the abstract is permitted for personal use only.

Finiteness Properties of Database Queries.

Abstract: We investigate the problem of checking whether the number of derivation trees of a Datalog program with duplicate semantics is nite or not. We show that given a safe stratiied query and an edb, it is possible to check, in polynomial time, whether the query has a nite number of derivation trees. However, it is undecidable to check whether a safe stratiied query has a nite number of derivation trees for every possible edb. We identify two classes of queries for which checking niteness over all edbs is decidable. We also deene duplicate semantics for Datalog (and thereby for the newly proposed variants of recursive SQL) queries with stratiied negation. Since evaluation involving counting of duplicates may not terminate in recursive SQL, this problem is of signiicant practical importance.

Conceptual Graphs for Relational Databases

Abstract: In order to apply conceptual graphs to Databases according to the indications of Sowa, we introduce λ-expressions and sets associated with CGs and introduce built-in relations to express general conditions for joining relations. The definition and test of well-formed query graphs is discussed as well as the evaluation of such a query. Views, deductive Databases and nested queries are shown to fit within this framework. Finally, we outline the ability of a CG base to cope with some Database problems where the relational model is too rigid with its separation of data from queries.

Value propagation in object-oriented database part hierarchies

Abstract: Derived schema components are an important aspect of traditional semantic data modeling. In this paper, we address the issue of defining such schema constructs in the context of object-oriented database (OODB) part hierarchies. In particular, we present the concept of derived attribute defined with respect to value propagation across a part relationship between two object classes. Three different types of value propagation, namely, invariant, transformational, and cumulative, allow for a high degree of expressiveness in the definition of such derived attributes. We also present the notion of a generalized derived attribute, which may be defined in terms of simultaneous value propagations across many part relationships. The ambiguity problem of multiple value propagation in part hierarchies is solved by this latter construct, an analogue of which is not applicable in ordinary 00DB IS-A hierarchies. It allows for the representation of such common expressions as the weight of the whole is the sum of the weights of the parts. To complement the form al definitions, we present a graphical schema notation for the value propagation mechanisms and the accompanying derived attributes. Such notation provides a convenient means for the specification and communication of OODB part schemata.

Tools for view generation in object-oriented databases

Abstract: This paper discusses two aspects of the objectoriented view management system, Multi View, which we designed to simplify view specification. First, we iniroduce a query language for view customization that operates on a complete schema, rather than deriving only individual virtual classes. This graph algebra promises to reduce the effort involved in view specification by lowering the number of queries necessary to dejine a view. Second, we introduce a tool that guarantees the composition of view classes into arbitrarily complex, yet consistent, view schemata. Unlike for relational views, generalization relationships in 00 views must be validated so that they are consistent with the global schema. In our system, we solve this problem by reformulating view schema construction as a classical graph theory problem, called minimal covering. This allows us to develop eficient algorithms that automatically generate a complete, minimal and consistent view schema. Proofs of correctness of these algorithms can be shown.

Implementing Conceptual Graphs in a RDBMS

Abstract: This paper discusses why the relational data model is inadequate for the modelling of certain data domains, and proposes that conceptual graphs can be used to remedy some of these inadequacies. A description of current research into implementing a conceptual graph layer on top of a relational database is given, along with some general algorithms for conceptual graph operations on relational database structures.

O-Raid: experiences and experiments

Abstract: We present the O-Raid distributed object-oriented database system, which is built by extending an existing relational database system called RAID. We compare the O-Raid data model with those of other systems and describe its design and implementation. We present the experimental data of studies performed to measure the overheads involved in supporting objects. Experiments included queries on objects in a single site, as well as queries on replicated composite objects spanning multiple sites. We also discuss the issues related to replication, indexing and fragmentation of objects. We conclude with our experiences and lessons learned in developing the O-Raid system. >

Relational Semantics for Flow Graph Representations as basis for Transformational Design of Digital Systems

Abstract: Transformational design is a promising design methodology which combines correctness by construction and interactive design. In this design methodology the design steps are behaviour preserving transformations of one design representation into another. The representations used in transformational design need to have formal semantical models in order to prove the correctness, the behaviour preserving characteristics, of transformations. This paper presents a formal semantical model for flow graphs based on a relational algebra. Flow graph representations have been shown to be useful in high level synthesis [1]. Together with the presented semantical model, flow graphs are also useful in transformational design.

Implementation of a graph-based data model for complex objects

Abstract: We have developed a graph-based data model called the Hypernode Model whose single data structure is the hypernode, a directed graph whose nodes may themselves reference further directed graphs A prototype database system supporting this model is being developed at London University as part of a project whose aims are threefold: (i) to ascertain the expressiveness and flexibility of the hypernode model, (ii) to experiment with various querying paradigms for this model, and (iii) to investigate the suitability of the directed graph as a data structure supported throughout all levels of the implementation The purpose of this paper is to report upon our findings to date

A methodology for evaluating parallel graph algorithms and its application to single source reachability

Abstract: The authors consider parallel processing of a graph represented by a database relation. They propose a methodology for analyzing the speedup of a parallel processing strategy with the purpose of selecting at run-time one of several candidate strategies, depending on the hardware architecture and the input graph. They study the single-source reachability problem, namely, the problem of computing the set of nodes reachable from a given node in a selected graph, propose several parallel strategies for solving this problem, and analyze their performance using the new methodology. The analysis is confirmed experimentally in a UNIX-Ethernet environment. >

A Graphical Interface to a Complex-Object Database Management System

Abstract: The research in database systems for new application areas has created several new architectural designs for database systems, among them the database kernel architecture We present a graphical interface which is located on top of such a database kernel system It provides an interface to the molecule-atom data model, which is a complex-object data model that serves as the basis for the implementation of various applications from new areas such as VLSI design Our interface is able to display the database schema graphically and allows the graphical formulation of queries Furthermore, it displays the results of queries as sets of complex objects Each of these objects corresponds to a directed graph The level of detail in the presentation of the results may be changed interactively Initially, for each element of the set one representative is shown The graph (ie the complex-object structure) corresponding to one or several elements of the result can be visualised For each node in a graph, its content (ie, the attribute values) can be displayed Furthermore, a type-oriented view to the components of the result set’s complex objects is provided

Design and implementation of a knowledge-based query processor

Abstract: This paper deals with query processing using semantic knowledge in relational databases. The Select-Project-Join (SPJ) conjunctive class of queries are dealt with in this paper. We propose to optimize highly repetitive queries by using semantic transformations in addition to syntactic transformations. Thus, we generate a set of pre-optimized queries. This set contains queries that are semantically equivalent to, syntactically different from, and more efficient to process than the user queries that we started with. The issues we address in this paper are: how to map a user query to a query that is in the set of pre-optimized and already optimized queries, how to search efficiently through the set of pre-optimized queries and set of semantic rules, and how to incorporate new queries to the set of pre-optimized queries, so that the number of queries that can be optimized using this method increases with the passage of time. Furthermore, we suggest some ideas of handling queries that do not have any semantically equivalent counterpart in the set of pre-optimized queries. We have tested the performance of the proposed method. An algorithm for mapping is implemented in Prolog. A database schema is implemented in the INGRES database management system. We have adopted a database schema that is widely used for measuring performance in the semantic query optimization literature.

Evaluation of Upper Bounds and Least Nodes as Database Operations

Abstract: We argue for supporting besides transitive closure two additional types of recursive queries in augmented relational database systems: the computation of upper bounds and least nodes in graphs that are persistently stored as database relations. We describe various algorithms for the evaluation of the specified query types. In essence, they vary in the kind of graph search, the search direction, the way how they prune search areas, and the way how they utilize intermediate results. Based on analytical results, we give a comparative assessment of the algorithms. The results of experiments substantiate our analytical findings.

Graph-based parallel query processing and data partitioning in object-oriented databases

Abstract: Object-oriented database management systems (OODBMSs) provide rich facilities for the modeling and processing of structural as well as behavioral properties of complex application objects. However, due to their inherent generality and continuously evolving functionalities, efficient implementations are important for these OODBMSs to support the present and future applications, particularly when the databases are very large. In this dissertation, we present several parallel, multi-wavefront algorithms based on two processing approaches, i.e., identification and elimination approaches, to verify association patterns specified in queries. Both approaches allow more processors to operate concurrently on a query than the traditional tree-structured query processing approach, thus introducing a higher degree of parallelism in query processing. A graph model is used to transform the query processing problem into a graph problem. Based on the graph model, proofs of correctness of both approaches for tree-structured queries are given, and a combined approach for solving cyclic queries is also provided and proved. A heuristic method is also presented for partitioning an OODB. The main consideration for partitioning the database is load balancing. This method also tries to reduce the communication time by reducing the length of the path that wavefronts need to be propagated. Multiple wavefront algorithms based on the two approaches for tree-structured queries have been implemented on an nCUBE 2 parallel computer. The implementation of the query processor allows multiple queries to be executed simultaneously. This implementation provides an environment for evaluating the algorithms and the heuristic method for partitioning the database. The evaluation results are presented in this dissertation.

GOLD : a graph oriented language for databases

Abstract: A simple and powerful graph transformation language for databases is defined whose operations are themselves graphs. It was designed to remedy some of the shortcomings of the GOOD language (see [20]), particularly, its restricted syntax for operations and its dependence on the rather awkward abstraction operator. The new language, GOLD, has only one operation; operations of GOOD are included as special cases. Thanks to a new idea, the core pattern, many more forms of node addition can be specified with this one operation; abstraction becomes superfluous. Due to its capability to add multiple nodes at once, GOLD surpasses GOOD in expressive power: queries are always generic determinate in the sense of [2] but they are not restricted to be constructive in the sense of [10J. The simpler forms of the GOLD operation have straightforward interpretations. Instead of imposing syntactic restrictions, the GOLD definition extends the semantics to cover a very broad range of expressions.

Modeling semantic integrity constraints in object-oriented database schemas

Abstract: Recent years have witnessed a continuous evolution of database models towards richer and more expressive paradigms. Along the line of enriching the modeling capabilities, Object-Oriented databases (OODBs) have been introduced. In this paper, we propose a further enhancement to OODB models aiming at enriching the database schema by explicitly declaring semantic integrity constraints therein.

Generating graph editors

Abstract: Software engineers use graphs to visualize and formalize many information domains, and there are considerable common capabilities among editors of these information domains. Domain-specific graph editors, e.g., a data-flow diagram editor, are a powerful and important part of software engineering techniques. However, such tools are hard to build, are often slow and ineffective, and become quickly out-dated as researchers develop new editing techniques. Furthermore, there is no guarantee that the design and implementation of these tools are applicable across information domains. This dissertation addresses the problem of creating a graph editor generator. The key to this problem is finding effective solutions to several component problems including, data definition, abstraction, graphic objects, layout, and communication. The Graph Editor Description Language (GEDL) and its translator provide the capability to specify and generate graph editors. The key features of this language are its propagation-based architecture, graph connectivity semantics, generalized abstraction, constraint-based layout, composable graphic objects, and communication support. This dissertation also presents a GEDL translator and examples of its use in generating graph editors. The translator implements various techniques for improving the usability of resulting graph editors including incremental constraint solution and control communication. Working examples of a task-dependence graph editor and constraint graph editor are presented to demonstrate the viability of the GEDL language and its translator. (Copies available exclusively from Micrographics Department, Doheny Library, USC, Los Angeles, CA 90089-0182.)

Nonschematic drawing recognition: a new approach based on attributed graph grammar with flexible embedding

Abstract: In this paper, we propose a syntactic pattern recognition method for non-schematic drawings, based on a new attributed graph grammar with flexible embedding. In our graph grammar, the embedding rule permits the nodes of a guest graph to be arbitrarily connected with the nodes of a host graph. The ambiguity caused by this flexible embedding is controlled with the evaluation of synthesized attributes and the check of context sensitivity. To integrate parsing with the synthesized attribute evaluation and the context sensitivity check, we also develop a bottom up parsing algorithm.© (1993) COPYRIGHT SPIE--The International Society for Optical Engineering. Downloading of the abstract is permitted for personal use only.