RDF is widely used as an ontology language for representing the metadata in Semantic Web, knowledge management system and E-commerce. Since ontologies model the knowledge in a particular domain, they may change over time. Furthermore, ontologies are usually developed and controlled in a distributed and collaborative way. Thus, it is very important to be able to manage multiple versions for RDF data. Earlier studies on RDF versions have focused on providing the accesses to different versions (i.e. snapshots) and computing the differences between those two versions. However, the existing approaches suffer from the space overhead for large scale data, since all snapshots should be redundantly kept in a repository. Moreover, it is very time consuming to compute the delta between two specific versions, which is very common in RDF applications. In this paper, we propose a framework for RDF version management in relational databases. It stores the original version and the deltas between two consecutive versions, thereby reducing the space requirement considerably. The other benefit of our approach is appropriate for change queries. On the flip side, in order to answer a query on a specific logical version, version should be constructed on the fly by applying the deltas between the original version and the logical version. This can slow down query performance. In order to overcome this, we propose a compression technique for deltas, called Aggregated Delta, to create a logical version directly rather than executing the sequence of deltas. An experimental study with real life RDF data sets shows our framework maintains multiple versions efficiently.

In this paper, targeting del.icio.us tag data, we propose a method, FolksoViz, for deriving subsumption relationships between tags by using Wikipedia texts, and visualizing a folksonomy. To fulfill this method, we propose a statistical model for deriving subsumption relationships based on the frequency of each tag on the Wikipedia texts, as well as the TSD (Tag Sense Disambiguation) method for mapping each tag to a corresponding Wikipedia text. The derived subsumption pairs are visualized effectively on the screen. The experiment shows that the FolksoViz manages to find the correct subsumption pairs with high accuracy.

An efficient object manager, a middle layer on top of a storage system, is essential to ensure acceptable performance of object-oriented database systems, since a traditional record-based storage system is too simple to provide object abstraction. In addition, an object storage system–object managers in combination with storage systems - should be extensible to meet the various requirements of emerging applications. In this research, we design and implement an extensible object storage system, called Soprano, in an object-oriented fashion which has shown great potential in extensibility and code reusability. Soprano provides a uniform object abstraction and gives us the convenience of persistent programming through many useful persistent classes. Also, Soprano supports efficient object management and pointer swizzling for fast object access. This paper investigates several aspects of the design and implementation of the extensible object storage system. Our experience shows the feasibility of using an object-oriented design and implementation in building an object storage system that should have both extensibility and high performance.

When accessing objects in an object-oriented database, performance can be greatly improved by prefetching objects efficiently. In this paper we present a new object prefetch policy, dynamic selective eager object fetch (SEOF), which prefetches objects only from selected candidate pages without using any high-level object semantics. Our policy considers both correlations and frequencies of fetching objects when selecting prefetch candidates. Unlike existing prefetch policies, dynamic SEOF utilizes the memory and the swap space of clients efficiently without resource exhaustion. Furthermore, the proposed policy has good adaptability to both the effectiveness of clustering and database size. It also adjusts the degree of prefetching dynamically according to the working environment. We show the performance of the proposed policy through experiments over various multi-client system configurations.

In this paper, we describe the design and implementation of the SOP Object Version System which is built upon an object database system, called SOP (SNU ODBMS Platform). SOP is fully compliant with ODMG-93, a standard for object databases proposed by the Object Database Management Group (ODMG). To support object versioning in an ODMG C++ OML (Object Manipulation Language) environment, the SOP Object Version System provides a set of APIs (Application Programming Interfaces) as a class library. One important design goal of the SOP Object Version System was to achieve full compliance with ODMG-93 standard. That is, in designing the class library, we tried to utilize the ODMG-93 C++ OML interface as much as possible, while preserving its semantics as defined in ODMG-93. Our object version model follows the basic functionalities of mainstream object version models. Although this approach burdens programmers with the management of the application-specific version policy, it helps users to apply the SOP Object Version System to diverse application areas. Copyright © 1999 John Wiley & Sons, Ltd.

The performance of object access can be drastically improved by an efficient object prefetch policy. In this paper, we present a new prefetch policy, called Selective Eager Object Fetch (SEOF), which prefetches objects only from selected candidate pages without using any high-level object semantics. Our policy considers both the correlations and the frequencies of fetching objects. Unlike existing prefetch policies, this policy utilizes the memory and the swap space of clients efficiently without resource exhaustion. Furthermore, the proposed policy has good adaptability to both the effectiveness of clustering and the database size. We show the performance of the proposed policy through experiments over various multi-client system configurations.

A 'class' in the object-oriented paradigm represents both interface and implementation of the class. However, interface and implementation of a class are needed for different purposes, since class interface is shared among most users, while class implementation is used only by the implementers of the class. The authors introduce a new level of data abstraction, called the 'class-implementation level', which is based on separate management of interface and implementation of a class. They also describe a new model for OODBMS which provides users with the abstract view of the class implementation.

C++ uses 'class' as the basis of 'subtype polymorphism' and 'inheritance', but it has been pointed out that the overloading of 'class' limits the expressiveness and makes its type system inflexible. This means that C++ and some other object oriented languages had to separate a class into two modules-an interface and an implementation. But, there seems to be no leading C++ model for separating the interface lattice from the implementation lattice. Moreover none of the proposed models describe the result of the separation in a formal way. As a result it is hard to understand what the type space would be like after the separation. The paper presents a formal model for the separation of interface and implementation in C++, and which explains the properties of the resulting type space after the separation.

To provide efficient search and retrieval of video data from large archives, we need to model video data appropriately. We propose a video data model and describe the design and implementation of the annotation-based video retrieval system VIRON (Video Information Retrieval On Notation) based on the proposed model. This model provides the mechanism of sharing and reusing annotations among users by introducing descriptor schema. In order to process a query efficiently, an annotated video unit is mapped into a unified video annotation stream. VIRON is composed of three tools: CVU manager, which is used to manage and visualize conceptual video units; annotator to annotate video data by offering an interactive video player; and a video query tool to pose and process video queries.

Abstract PICASSO (PICture Aided Sophisticated Sketch Of database queries) is a graphics‐based database query language designed for use with a universal relation database system. The primary objective of PICASSO is ease of use. Graphics are used to provide a simple method of expressing queries and to provide visual feedback to the user about the system's interpretation of the query. Inexperienced users can use the graphical feedback to aid them in formulating queries whereas experienced users can ignore the feedback. Inexperienced users can pose queries without knowing the details of underlying database schema and without learning the formal syntax of SQL‐like query language. This paper presents the syntax of PICASSO queries and compares PICASSO queries with similar queries in standard relational query languages. Comparisons are also made with System/U, a non‐graphical universal relation system on which PICASSO is based. The hypergraph semantics of the universal relation are used as the foundation for PICASSO and their integration with a graphical workstation enhances the usability of database systems.

Object-oriented programming is well-suited to such data-intensive application domains as CAD/CAM, AI, and OIS (office information systems) with multimedia documents. At MCC we have built a prototype object-oriented database system, called ORION. It adds persistence and sharability to objects created and manipulated in applications implemented in an object-oriented programming environment. One of the important requirements of these applications is schema evolution, that is, the ability to dynamically make a wide variety of changes to the database schema. In this paper, following a brief review of the object-oriented data model that we support in ORION, we establish a framework for supporting schema evolution, define the semantics of schema evolution, and discuss its implementation.

Presented in this paper is the data model for ORION, a prototype database system that adds persistence and sharability to objects created and manipulated in object-oriented applications. The ORION data model consolidates and modifies a number of major concepts found in many object-oriented systems, such as objects, classes, class lattice, methods, and inheritance. These concepts are reviewed and three major enhancements to the conventional object-oriented data model, namely, schema evolution, composite objects, and versions, are elaborated upon. Schema evolution is the ability to dynamically make changes to the class definitions and the structure of the class lattice. Composite objects are recursive collections of exclusive components that are treated as units of storage, retrieval, and integrity enforcement. Versions are variations of the same object that are related by the history of their derivation. These enhancements are strongly motivated by the data management requirements of the ORION applications from the domains of artificial intelligence, computer-aided design and manufacturing, and office information systems with multimedia documents.