In new application areas of relational database systems, such as artificial intelligence, the join operator is used more extensively than in conventional applications. In this paper, we propose a simple data structure, called a join index, for improving the performance of joins in the context of complex queries. For most of the joins, updates to join indices incur very little overhead. Some properties of a join index are (i) its efficient use of memory and adaptiveness to parallel execution, data type join predicates, (iv) its support for multirelation clustering, and (v) its use in representing directed graphs and in evaluating recursive queries. Finally, the analysis of the join algorithm using join indices shows its excellent performance.

.<F3.733e+05> Physical data independence is touted as a central feature of modern database systems. It allows users to frame queries in terms of the logical structure of the data, letting a query processor automatically translate them into optimal plans that access physical storage structures. Both relational and object-oriented systems, however, force users to frame their queries in terms of a logical schema that is directly tied to physical structures. We present an approach that eliminates this dependence. All storage structures are defined in a declarative language based on relational algebra as functions of a logical schema. We present an algorithm, integrated with a conventional query optimizer, that translates queries over this logical schema into plans that access the storage structures. We also show how to compile update requests into plans that update all relevant storage structures consistently and optimally. Finally, we report on experiments with a prototype implementation ...

Abstract. Collaborative knowledge base (KB) authoring environments are critical for the construction of high-performance KBs. Such environments must support rapid construction of KBs by a collaborative e ort of teams of knowledge engineers through reuse of existing knowledge and software components. They should support the manipulation of knowledge by diverse problem-solving engines even if that knowledge is encoded in di erent languages and by di erent researchers. They should support large KBs and provide a scalable and interoperable development infrastructure. In this paper, we present anenvironment that satis es many of these goals. We present an architecture for scalable frame representation systems (FRSs). The Generic Frame Protocol (GFP) provides infrastructure for reuse of software components. It is a procedural interface to frame representation systems that provides a common means of accessing and modifying frame KBs. The Generic KB Editor (Gkb-Editor) provides graphical KB browsing, editing, and comprehension services for large KBs. Scalability of loading and saving time is provided by a storage system (PERK) which submerges a database management system in an FRS. Multi-user access is controlled through a collaboration subsystem that uses a novel optimistic concurrency control algorithm. All the results have been implemented and tested in the development of several real KBs.

The generation of execution plans for object-oriented database queries is a new and challenging area of study. Unlike the relational algebra, a common set of object algebra operators has not been defined. Similarly, a standardized object manager interface analogous to storage manager interfaces of relational subsystems does not exist. We define the interface to an object manager whose operations are the executable elements of query execution plans. Parameters to the object manager interface are streams of tuples of object identifiers. The object manager can apply methods and simple predicates to the objects identified in a tuple. Two algorithms for generating such execution plans for queries expressed in an object algebra are presented. The first algorithm runs quickly but may produce inefficient plans. The second algorithm enumerates all possible execution plans and presents them in an efficient, compact representation. Keywords: object-oriented databases, query processing, query opt...

.<F3.733e+05> Advanced applications in fields such as CAD, software engineering, real-time process control, corporate repositories and digital libraries require the construction, efficient access and management of large, shared knowledge bases. Such knowledge bases cannot be built using existing tools such as expert system shells, because these do not scale up, nor can they be built in terms of existing database technology, because such technology does not support the rich representational structure and inference mechanisms required for knowledge-based systems. This paper proposes a generic architecture for a knowledge base management system intended for such applications. The architecture assumes an object-oriented knowledge representation language with an assertional sublanguage used to express constraints and rules. It also provides for general-purpose deductive inference and special-purpose temporal reasoning. Results reported in the paper address several knowledge base management ...

Physical design for object-oriented databases is still in its infancy. Implementation decisions often intrude into the conceptual design (such as inverse links and object decomposition). Furthermore, query optimizers do not always take full advantage of physical design information. This paper proposes a formal framework for physical database design that automates the query translation process. In this framework, the physical database design is specified in a declarative manner. This specification is used for generating an efficient query transformer that translates logical queries into programs that manipulate the physical database. Alternative access paths to physical data are captured as simple rewrite rules that are used for generating alternative plans for a query. 1 Introduction One important advantage that commercial database systems offer is data independence, whereby abstract objects and the operations upon them can be significantly decoupled from their implementations. In a r...

We propose an architecture for implementing nested re- In this paper we propose an implementation, ANDA’ lational databases. In particular, we discuss the storage for the Nested Relational Data Model(NRJ3M). In parstructures, their organization and an access language titular, we diicuaa the storage structures, their orgafor specifying access plans. nization, and an access language for specifying access The featurw of our implementation are: plans. The motivation for our design comes from these observations: A notation for hierarchical tuple identification. One value-driven indexing structure (VALTREE) for the entire database. A main-memory based component (CACHE) for ma-nipulating hierarchical tuple-identifiers. A hashing scheme (RECLISTS) for fast access to data specified by tuple-identifiers. An access language based on the VALTREE, the RECLIST and the CACHE to define access plans for execution of queries. Pemusaon to copy without fee all ar put of this granted pvided that the oopies are not made or disrritutcd for direct commercial advantage, the VLDB cop&ht notice md the title of the public&m and its date s~~eer, and notice L given

Database systems that can efficiently manage complex objects are increasingly needed in many different fields such as office automation, knowledge processing, CAD/CAM, CASE, etc. A lot of recent complex object database systems support the concepts of object identity and object identifier. Following an object identifier to access the referenced object is called navigation operation and is an essential operation in dealing with complex objects. Navigation operation is a difficult operation to implement efficiently since every navigation operation inherently causes one disk access operation. This paper proposes a scheme to notably accelerate the navigation operation among a sea of complex objects, by increasing the effectivenumber of objects in one disk page. The main concept of the presented technique is threefold: The first is to store a cached value within a complex object that is referencing another complex object. The second is that when the referenced object is to be updated the update propagation is delayed until the time when the cached value is referenced. Lastly, the third idea is to utilize a hashed table on main memory to efficiently validate the consistency between the cached values and the original values. Index terms --- Complex objects, object-oriented database, object identity, persistent objects, caching, and delayed update propagation. I

In recent years, there has been a growing demand for the development of tools to manage enterprise communication networks. A management information database is the heart of a network management system -- it provides the interface between all functions of the network management system, and therefore has to provide sophisticated functionality allied with high performance. In this paper, we introduce the design of MANDATE (MAnaging Networks using DAtabase TEchnology), a proposed database system for effectively supporting the management of large enterprise networks. The MANDATE design makes a conscious attempt to take advantage of the special characteristics of network data and transactions, and of recent advances in database technology, to efficiently derive some of the required management functionality.

We address the generation of execution plans for object-oriented database queries. This is a challenging area of study because, unlike the relational algebra, a uniformly accepted set of object algebra operators has not been defined. Additionally, a standardized object manager interface analogous to storage manager interfaces of relational systems does not exist. We define the interface to an object manager whose operations are the executable elements of query execution plans. Parameters to the object manager interface are streams of tuples of object identifiers. The object manager can apply methods and simple predicates to the objects identified in a tuple. Two algorithms for generating execution plans for queries expressed in an object algebra are presented. The first algorithm runs quickly but may produce inefficient plans. The second algorithm enumerates all possible execution plans and presents them in an efficient, compact representation. 1 Introduction There is significant inte...