Showing papers on "Graph database published in 1990"

Relational database management system and method for storing, retrieving and modifying directed graph data structures

Abstract: An improved database management system (DBMS) stores, retrieves and manipulates directed graph data structures in a relational database. Each directed graph data structure contains one or more records of data which are interconnected by pointers. Data is stored in the database in the form of two dimensional tables, also known as flat files. The improved DBMS defines a schema for each table in the database. The schema defines the name and data type of each column in a database table. In tables used to store directed graph data structures, at least one column will be defined as having a reference data type. Non-empty entries in that column are pointers to rows in a specified table. Directed graph data structures are stored in specified tables by storing each record of the directed graph in a distinct row of one of the specified tables, with references corresponding to interconnections between records being stored in reference data type columns. Portions of a directed graph are retrieved from the specified table, in accordance with a single specified query and then the query is automatically expanded by also retrieving additional portions of the tables which are referenced by the previously retrieved portions, thereby performing a transitive closure. The retrieved data is stored in a buffer as a list of rows, and then communicated to an application process. An interface program converts the list of rows stored in the buffer into a directed graph data structure.

Parallel database systems: the future of database processing or a passing fad?

Abstract: The concept of parallel database machines consisting of exotic hardware has been replaced by a fairly conventional shared-nothing hardware base along with a highly parallel dataflow software architecture. Such a design provides speedup and scaleup in processing relational database queries. This paper reviews the techniques used by such systems, and surveys current commercial and research systems.

The G+/GraphLog Visual Query System

Abstract: The video presentation “The G+/GraphLog Visual Query System” gives an overview of the capabilities of the ongoing implementation of the G+ Visual Query System for visualizing both data and queries as graphs. The system provides an environment for expressing queries in GraphLog [Con89, CM89, CM90], as well as for browsing, displaying and editing graphs. The visual query system also supports displaying the answers in several different ways.Graphs are a very natural representation for data in many application domains, for example, transportation networks, project scheduling, parts hierarchies, family trees, concept hierarchies, and Hypertext. From a broader perspective, many databases can be naturally viewed as graphs. In particular, any relational database in which we can identify one or more sets of objects of interest and relationships between them can be represented by mapping these objects into nodes and relationships into edges. In the case of semantic and object-oriented databases, there is a natural mapping of objects to nodes and attributes to edges.GraphLog is a visual query language, based on a graph representation of both data and queries, that has evolved from the earlier language G+ [CMW87, CMW89, MW89]. GraphLog queries ask for patterns that must be present or absent in the database graph. Each such pattern, called a query graph, defines new edges that are added to the graph whenever the pattern is found. GraphLog queries are sets of query graphs, called graphical queries. If, when looking at a query graph in a graphical query, we do not find an edge label in the database, then there must exist another query graph in the graphical query defining that edge. The language also supports computing aggregate functions and summarizing along paths.The G+ Visual Query System is currently implemented in Smalltalk-80™, and runs on Sun 3, Sun 4 and Macintosh II workstations. A Graph Editor is available for editing query graphs and displaying database graphs. It supports graph “cutting and pasting”, as well as text editing of node and edge labels, node and edge repositioning and re-shaping, storage and retrieval of graphs as text files, etc. Automatic graph layout is also provided. For editing collections of graphs (such as graphical queries) a Graph Browser is available.The first answer mode supported by the G+ Visual Query System is to return as the result of a GraphLog query a graph with the new edges defined by the graphical query added to the database graph.An alternative way of visualizing answers is by high-lighting on the database graph, one at a time, the paths (or just the nodes) described by the query. This mode is particularly useful to locate interesting starting points for browsing.Rather than viewing the answers superimposed on the database graph, the user may choose to view them in a Graph Browser. The Graph Browser contains the set of subgraphs of the database graph that were found to satisfy the query.Finally, the user may select to collect all the subgraphs of the database graph that satisfy the query together into one new graph. This graph (as well as any other result graph from any of the above mentioned answer modes) in turn may be queried, providing a mechanism for iterative filtering of irrelevant information until a manageable subgraph is obtained.

A Specification Environment for Graph Grammars

Abstract: Modelling environments (e.g. software development environments) offer tools which build up and maintain complex internal data structures. Therefore, before implementing such tools, it is advisable for the tool developer to formally specify the structure and the operations of these internal data structures. Graph Grammars as an operational specification method have been successfully used for this purpose for many years.

Experimental investigation of the utility of data structure and E-R diagrams in database query

Abstract: We empirically tested several graphical forms of database documentation to determine their utility in the performance of database queries. The data structure diagram and the entiry-relationship diagram were shown to be helpful in performing queries on a relational database.

Graph data model and its data language

Abstract: Spend your few moment to read a book even only few pages. Reading book is not obligation and force for everybody. When you don't want to read, you can get punishment from the publisher. Read a book becomes a choice of your different characteristics. Many people with reading habit will always be enjoyable to read, or on the contrary. For some reasons, this graph data model and its data language tends to be the representative book in this website.

GraphEd: An Interactive Tool For Developing Graph Grammars

Abstract: GraphEd is a powerful interactive editor for drawing and manipulating graphs and graph grammars. It helps designing graphs, networks, data structures, entity relationship diagrams, petri nets, electrical circuits, VLSI circuits, flowcharts or even arbitrary diagrams. Its unique feature is the ability to handle graph grammars. They are useful both for theoretical investigations and as parametrisized graph macros.

BRMQ: a database interface facility based on graph traversals and extended relationships on groups of entities

Abstract: A binary relational database model is used as the heart of a coexistent database system architecture. The semantic binary relational model (SBRM) of information allows for evolutionary changes in the data base by breaking large constructs into atomic named objects. A graph representation of the SBRM schemas is used as an effective data base interface. Such an interface allows interrogation of the database by employing a sequence of graphical movements based on the schema graphs displayed on the screen. This paper describes a data base interface language which is based on manipulating graphical images of objects in an SBRM graph

A graph grammar approach to concurrent programming

Abstract: We propose the use of graph grammars as a theory to organize programming of highly-concurrent systems. To understand the interactions among components of a concurrent system it is useful to visualize the system as dynamically changing graphs where the nodes represent concurrent components and the edges represent (the possibility of) interactions among them. Graph grammars are effective tools for translating this intuitive understanding of system behavior into formal specifications and executable concurrent programs. We claim that the use of hybrid graphical/textual languages is an important way to effectively specify and clearly understand the dynamic behavior of concurrent systems. This is because the problem is divided into two parts, the graphical part of understanding object relationships and the textual part of understanding internal object behavior. We develop theory necessary to support this division of labor. Problems that are addressed include: modifying and using existing graph grammar theory to get a formal way to express and to reason graphically about the dynamic behavior of concurrent programs, fitting both text and graphics into a unified semantic framework and building real hybrid graphical/textual languages using the theory introduced. In order to ground our ideas in the context of graph grammar research, we propose an algebraic model, $\Delta$-G scRAMMARS, and give it a semantics. $\Delta$-G scRAMMARS are reflective, concurrent and fair in production application, and incorporate a notion of Kleene star-like graph rewriting. The result is a powerful, but low-level paradigm for defining graph languages. Existing semantics that try to take both textual and graphical elements into account are text-based. In contrast, we show how graphically-based semantics can be given using $\Delta$-G scRAMMARS, and justify why this is useful. Such $\Delta$-semantics provides a coherent framework to consider both text and graphics. Finally, using $\Delta$-semantics we give the definition of a higher-level programming language. The higher-level language includes facilities for graph rewriting, message passing (synchronous and asynchronous) and imperative style programming. The methods for defining and using these facilities that mix graphical and textual concepts are supported by the graph grammar and graphical semantics base that has been developed. A tutorial introduction to graph grammars is also included.

Graph matching in operational semantics and typing

Abstract: Graph reduction has been used for some years as an implementation technique for functional programming languages [Wadsworth 71], [Turner 79], [Cardelli 83], [Peyton Jones 87], and it has been proved that graph reduction implements various (tree-based) languages and rewrite systems correctly [Staples 78, 80], [Barendregt et al. 87]. More recently proper graph languages have appeared as intermediate languages for term rewriting systems, cf. [Kennaway 88], [Barendregt et al. 87b]. Thus it appears that graph concepts are well suited to solve problems arising with such languages. We propose to exploit this by using graph concepts in semantic descriptions of functional languages, and we describe "Graph Semantics" based on graph concepts and Structured Operational Semantics [Plotkin 81]. The method involves representing all static information of a program in a partial order and a graph such that all further computations and reasoning about the program can be done on this representation. The method appears to form a natural framework for the description of constructortyped languages, and we describe an extension that makes it possible to describe recursively typed languages by representing the type information in graphs. We illustrate this by giving the complete Graph Semantics of a recursively typed normal order A-calculus. Finally we briefly discuss a simple and naive graph reduction machine which supports our primitive graph operations and provides a base for language implementations; we are currently building a system to generate graph reduction machine programs from graph semantic descriptions.

Transforming syntactic graphs into semantic graphs

Abstract: In this paper, we present a computational method for transforming a syntactic graph, which represents all syntactic interpretations of a sentence, into a semantic graph which filters out certain interpretations, but also incorporates any remaining ambiguities. We argue that the resulting ambiguous graph, supported by an exclusion matrix, is a useful data structure for question answering and other semantic processing. Our research is based on the principle that ambiguity is an inherent aspect of natural language communication.

Semantic modeling through identification and characterization of objects

Abstract: So-called semantic data models represent the structure of some part of reality, on the one hand, and the structure of the data in some database system, on the other hand. Semantic modeling is an important tool for database design. Several techniques and tools for semantic modeling have been proposed [2, 4]. A new approach to semantic modeling — the ICAROS approach — will be presented here.

A clustering method using the strength of citation

Abstract: A new method for modelling and clustering a relational graph produced from the citation relation among scientific articles is discussed. One article corresponds to a point and a citation link corresponds to a directed walk in the graph. This graph is a direct-citation graph and a total-citation graph is derived from it. There exist two types of directed citation graph; i.e., citing directed-graph and cited directed-graph. The former is considered in this paper. These graphs are repre sented in the form of similarity matnces which are asymmetric. The characteristics of these graphs are analyzed by clustering. For this study, a research database was designed and produced to acquire bibliographic information and obtain relations be tween articles in it. A modelling methodology of its relational structure is described in this article. Combinatonal clustering methods have been examined and a clustering method for an asymmetric similarity matrix is also proposed.

Representation and manipulation of heterogenous graph data objects

Abstract: This dissertation addresses the data modeling, organization, storage, and accessing of a class of data objects called graph data objects. All graph data objects have one thing in common--their underlying graph structure. A graph data object can be mapped into a graph by mapping its components into the nodes and edges of the graph. The study concentrates on the representation and manipulation of graph data objects. In the representation problem, the objective is to find a suitable representation system for modeling and storing graph objects. For the manipulation part, the goal is to design a query language for manipulating graph data objects. A new data model, based on the mathematical concept of graph, is proposed and defined. The model is shown to provide a natural and direct representation for graph objects. In order to query and manipulate graph objects represented in the new data model, this dissertation provides the design and formal specification of a graph manipulation language. The query language generalizes an existing structured query language (the SQL) with the capability to support a wide range of operations on graph objects. The 'physical appearance' of graph objects varies from application to application and depends entirely on application domains. Therefore, there does not exist a single, unique way of displaying all graph objects. This dissertation studies this problem and develops two approaches to the display (layout) of graph objects. The first is a rule-based approach, in which the display characteristics of a class of graph objects are stated in a set of rules. These rules can then be used by an inference engine to derive a layout for any data instance within the graph class. The second approach is based on the idea of repeatedly splitting a graph object into smaller ones until each is small enough to be solved effectively by the first approach. This dissertation also studies the problem of the evaluation and optimization of a component of the new query manipulation language. Algorithms for query evaluation and optimization are developed and implemented. The performance of the algorithms is studied using simulation.

Computing transitive closures of multilevel relations

Abstract: Recently many attempts have been made to implement recursive queries. Such queries are essential for the new generation intelligent database system applications. Much of the effort in recursive queries is focussed on transitive closure queries which are of practical significance. None of the work described investigates recursive query processing in secure database management systems. In this paper we propose centralized and distributed algorithms for implementing transitive closure queries for multilevel secure relational database management systems.

Performing logical database design using an E-R graph rewriting system

Abstract: The authors present a formalism which restricts the freedom of connecting different entity-relationship constructs so that only syntactically and semantically well-formed diagrams can be designed. The methods used in this formalism are graph rewriting for the generation of conceptual structures, string rewriting for graph markings, and assertions for establishing the semantic correctness of the generated diagram. The main purpose of this research work is the formal specification of a design tool which supports relational database design with different design goals. Further goals are the ease of application of the resulting methodology, even without tool support, and the possibility of changing the behavior of the design tool easily. >

A communication network for distributed database systems

Abstract: A graph traversal algorithm and its application to a dynamically partitionable bus network for a distributed database system are presented. The approach can be summarized as follows: (1) transform database operations into a graph where vertices represent database operations and edges denote the conflicts of using system resources among database operations, (2) color the constructed graph so that the vertices corresponding to the nonconflicting database operations are assigned the same color, and (3) allow the nonconflicting database operations to proceed in parallel. The graph traversal algorithm, used to color the vertices of a graph is described. The dynamic bus partitioning technique for a distributed database system is delineated. >

Recursive Query Processing in Predicate-Goal Graph

Abstract: The predicate-goal graph (P-G graph) is introduced in this paper to facilitate query processing with linear recursive function-free Horn clauses without negation. A recursive rule is compiled into (an infinite number of) expansions. Each expansion corresponds to a P-G subgraph. The necessary and sufficient condition of existence of an answer to a query is that one P-G subgraph is satisfiable. Two basic recursive query processing strategies, the bottom-up evaluation and the Prolog computation, are illustrated using the P-G graph. In the P-G graph, query evaluation can be independent of the order of the predicates in the rule expression and many query processing strategies may be used. This graphic method can be used for comparisons of various recursive query processing strategies, parallel processing, query optimization, etc.

Fast Parallel Algorithms on a Class of Graph Structures With Applications in Relational Databases and Computer Networks.

Abstract: The quest for efficient parallel algorithms for graph related problems necessitates not only fast computational schemes but also requires insights into their inherent structures that lend themselves to elegant problem solving methods. Towards this objective efficient parallel algorithms on a class of hypergraphs called acyclic hyper­ graphs and directed hypergraphs are developed in this thesis. Acyclic hypergraphs are precisely chordal graphs and its subclasses, and they have applications in rela­ tional databases and computer networks. In this thesis, firstly, we present efficient parallel algorithms for the following problems on graphs. determining whether a graph is strongly chordal, ptolemaic, or a block graph. If the graph is strongly chordal, determine the strongly perfect vertex elimination ordering. determining the minimal set of edges needed to make an arbitrary graph strongly chordal, ptolemaic, or a block graph. determining the minimum cardinality dominating set, connected dominating set, total dominating set, and the domatic number of a strongly chordal graph. Secondly, we show that the query implication problem (Q 1 —> <2 2) on two queries, which is to determine whether the data retrieved by query Q x is always a sub­ set of the data retrieved by query Q 2, is not even in NP and in fact complete in U2P . We present several ‘fine-grain’ analysis of the query implication problem and show that the query implication can be solved in polynomial time given chordal queries. Thirdly, we develop efficient parallel algorithms for manipulating directed hypergraphs H such as finding a directed path in H , closure of H , and minimum equivalent hypergraph of H . We show that finding a directed path in a directed hypergraph is inherently sequential. For directed hypergraphs with fixed degree and diameter we present NC algorithms for manipulations. Directed hypergraphs are representation schemes for functional dependencies in relational databases. Finally, we also present an efficient parallel algorithm for multi-dimensional range search. We show that a set of points in a rectangular parallelepiped can be obtained in O (logn) time with only 2.1og2« 10.logn + 14 processors on a EREWPRAM. A non-trivial implementation technique on the hypercube parallel architec­ ture is also presented. Our method can be easily generalized to the case of ddimensional range search.

USING JOIN OPERATlONS AS REDUCERS IN DISTRlBUTED QUERY PROCESSING

Abstract: Scmijoin has traditionally been relied upon for reducing the communication cost required for distr-iburcd query prcjcessing. Ilowever, judiciously applying join nperations as rcduccrs can lead to further reduction in the communication cost. In view of this fact, we explore in this paper the approach of using join operations, in addition to semijoins, as rcduccrs in distributed query processing. We first show that the problem of determining a sequence of join operations for a query graph can he transformed to that of iinding a set of cuts to that graph, where a cut to a graph is a partition of the nodes in that graph. In light of the mapping we develop an eff%ient heuristic algorithm to dctcrminc an cffcctive scqucnce of join reducers for a query. The algorithm using the concept of divide-and-conquer is shown to hnvc polynomial time complexity. Examples are also given to illustrafc our results.