Physical Data Independence Research Articles

DF-toolkit

Applications in several areas, such as privacy, security, and integrity validation, require direct access to database management system (DBMS) storage. However, relational DBMSes are designed for physical data independence, and thus limit internal storage exposure. Consequently, applications either cannot be enabled or access storage with ad-hoc solutions, such as querying the ROWID (which can expose physical record location within DBMS storage but not within OS storage) or using DBMS "page repair" tools that read and write DBMS data pages directly. Such ad-hoc methods are limited in their capabilities and difficult to program, maintain, and port across various DBMSes. In this demonstration, we showcase DF-Toolkit - a set of tools that provide an abstracted access to the DBMS storage layer. Users will be able to view DBMS storage not accessible through other applications. Examples include unallocated (e.g., deleted) data, index value-pointer pairs, and cached DBMS pages in RAM. Users will also be able to interact with several special-purpose security applications that audit DBMS storage beyond what DBMS vendors support.

$$\uptau $$ τ OWL: A Systematic Approach to Temporal Versioning of Semantic Web Ontologies

The W3C OWL 2 recommendation is an ontology language for the Semantic Web. It allows defining both schema (i.e., entities, axioms, and expressions) and instances (i.e., individuals) of ontologies. However, OWL 2 lacks explicit support for time-varying schema or for time-varying instances. Hence, knowledge engineers or maintainers of semantics-based Web resources have to use ad hoc techniques to specify OWL 2 time-varying ontologies. In this paper, for a disciplined and systematic approach to the temporal management of Semantic Web ontologies, we propose the adoption of a framework called temporal OWL 2 (\(\uptau \)OWL), which is inspired by the \(\uptau \)XSchema framework defined for XML data. In a way similar to what happens in \(\uptau \)XSchema, \(\uptau \)OWL allows creating a temporal OWL 2 ontology from a conventional (i.e., non-temporal) OWL 2 ontology and a set of logical and physical annotations. Logical annotations identify which elements of the ontology can vary over time; physical annotations specify how the time-varying aspects are represented in the OWL 2 document. Using annotations to integrate temporal aspects in the traditional Semantic Web, our framework (1) guarantees logical and physical data independence for temporal schemas and (2) provides a low-impact solution, since it requires neither modifications of existing Semantic Web ontologies, nor extensions to the OWL 2 recommendation and Semantic Web standards. Moreover, since the conventional schema and annotation documents could evolve over time to respond to new applications’ requirements, \(\uptau \)OWL supports temporal schema versioning by allowing changing these components and by keeping track of their evolution through the conventional schema versions and annotation document versions, respectively. Two complete sets of operations are proposed for changing the conventional schema and annotation documents; to complete the figure, a set of operations is also introduced for updating temporal schema which must be changed consequently each time one of the mentioned components evolves over time. To show the feasibility of our approach, a prototype tool, named \(\uptau \)OWL-Manager, is presented.

A survey of B-tree logging and recovery techniques

B-trees have been ubiquitous in database management systems for several decades, and they serve in many other storage systems as well. Their basic structure and their basic operations are well understood including search, insertion, and deletion. However, implementation of transactional guarantees such as all-or-nothing failure atomicity and durability in spite of media and system failures seems to be difficult. High-performance techniques such as pseudo-deleted records, allocation-only logging, and transaction processing during crash recovery are widely used in commercial B-tree implementations but not widely understood. This survey collects many of these techniques as a reference for students, researchers, system architects, and software developers. Central in this discussion are physical data independence, separation of logical database contents and physical representation, and the concepts of user transactions and system transactions. Many of the techniques discussed are applicable beyond B-trees.

MiniCon: A scalable algorithm for answering queries using views

The problem of answering queries using views is to find efficient methods of answering a query using a set of previously materialized views over the database, rather than accessing the database relations. The problem has received significant attention because of its relevance to a wide variety of data management problems, such as data integration, query optimization, and the maintenance of physical data independence. To date, the performance of proposed algorithms has received very little attention, and in particular, their scale up in the presence of a large number of views is unknown. We first analyze two previous algorithms, the bucket algorithm and the inverse-rules, and show their deficiencies. We then describe the MiniCon, a novel algorithm for finding the maximally-contained rewriting of a conjunctive query using a set of conjunctive views. We present the first experimental study of algorithms for answering queries using views. The study shows that the MiniCon scales up well and significantly outperforms the previous algorithms. We describe an extension of the MiniCon to handle comparison predicates, and show its performance experimentally. Finally, we describe how the MiniCon can be extended to the context of query optimization.

Theory of answering queries using views

The problem of answering queries using views is to find efficient methods of answering a query using a set of previously materialized views over the database, rather than accessing the database relations. The problem has recently received significant attention because of its relevance to a wide variety of data management problems, such as query optimization, the maintenance of physical data independence, data integration and data warehousing. This article surveys the theoretical issues concerning the problem of answering queries using views.

Towards data abstraction in networked information retrieval systems

Networked information retrieval aims at the interoperability of heterogeneous information retrieval (IR) systems. In this paper, we show how differences concerning search operators and database schemas can be handled by applying data abstraction concepts in combination with uncertain inference. Different data types with vague predicates are required to allow for queries referring to arbitrary attributes of documents. Physical data independence separates search operators from access paths, thus solving text search problems related to noun phrases, compound words and proper nouns. Projection and inheritance on attributes support the creation of unified views on a set of IR databases. Uncertain inference allows for query processing even on incompatible database schemas.

The GMAP: a versatile tool for physical data independence

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 of our approach that demonstrate how it allows storage structures to be tuned to the expected or observed workload to achieve significantly better performance than is possible with conventional techniques.

Device and physical data independence for multimedia presentations

article Free Access Share on Device and physical data independence for multimedia presentations Authors: Richard Staehli Oregon Graduate Institute of Science & Technology, Portland Oregon Graduate Institute of Science & Technology, PortlandView Profile , Jonathan Walpole Oregon Graduate Institute of Science & Technology, Portland Oregon Graduate Institute of Science & Technology, PortlandView Profile , David Maier Oregon Graduate Institute of Science & Technology, Portland Oregon Graduate Institute of Science & Technology, PortlandView Profile Authors Info & Claims ACM Computing SurveysVolume 27Issue 4Dec. 1995 pp 640–642https://doi.org/10.1145/234782.234811Published:01 December 1995Publication History 2citation346DownloadsMetricsTotal Citations2Total Downloads346Last 12 Months8Last 6 weeks2 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my Alerts New Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF

A quality-of-service specification for multimedia presentations

The bandwidth limitations of multimedia systems force trade-offs between presentation-data fidelity and real-time performance. For example, digital video is commonly encoded with lossy compression to reduce bandwidth, and frames may be skipped during playback to maintain synchronization. These trade-offs depend on device performance and physical data representations that are hidden by a database system. If a multimedia database is to support digital video and other continuous media data types, we argue that the database should provide a quality-of-service (QOS) interface to allow application control of presentation timing and information-loss trade-offs. This paper proposes a data model for continuous media that preserves device and physical data independence. We show how to define formal QOS constraints from a specification of ideal presentation outputs. Our definition enables meaningful requests for endto-end service guarantees, while leaving the database system free to optimize resource management. We propose one set of QOS parameters that constitute a complete model for presentation error, and we show how this error model extends the opportunities for resource optimization.

Options in physical database design

A cornerstone of modern database systems is physical data independence, i.e., the separation of a type and its associated operations from its physical representation in memory and on storage media. Users manipulate and query data at the logical level; the DBMS translates these logical operations to operations on files, indices, records, and disks. The efficiency of these physical operations depends very much on the choice of data representations. Choosing a physical representation for a logical database is called physical database design. The number of possible choices in physical database design is very large; moreover, they very often interact with each other. We attempt to list and classify these choices and to explore their interactions. The purpose of this paper is to provide an overview of possible options to the DBMS developer and some guidance to the DBMS administrator and user. While much of our discussion will draw on the relational data model, physical database design is of even more importance for object-oriented and extensible systems. The reasons are simple: First, the number of logical data types and their operations is larger, requiring and permitting more choices for their representation. Second, the state of the art in query optimization for these systems is much less developed than for relational systems, making careful physical database design even more imperative for object-oriented database systems.

PIQUE: A relational query language without relations

Relational database systems have gone far towards providing users with physical data independence. To use a relational database, users need not know the physical storage structures of relations, and are protected from changes in these structures. However, a user must still navigate among relations. In other words, if the information needed to answer a question spans several relations, he must explicitly specify how these relations are to be combined. Physical data independence is not enough. A user should also be afforded some degree of structural data independence. More specifically, he should be able to pose queries without having to explicitly navigate among relations in the database. Instead, the system should do the navigation for him. We consider universal scheme interfaces as a means for automatic database navigation, and introduce the concept of a generator as central to such navigation. We describe a particular generator based on the semantic notions of reducible and irreducible facts, and present PIQUE, an attribute-based query language designed to work with this generator. PIQUE is a concise, yet powerful, language with natural semantics. A distinguishing feature of PIQUE is that tuple variables in queries are bound implicitly and that the logical connectives “and”, “or,” and “not” can affect the binding, and, therefore, take on “semantic overtones.” Furthermore, the semantic interpretation PIQUE gives to these connectives is more natural than the one given by most other query languages. In the Appendix, we present PIQUE's formal syntax and semantics, along with the proof that PIQUE is relationally complete.

Creating a conceptual model of a data dictionary for distributed data bases

Distributed Data bases (DDB), which have been for many yearsthe object of research and experiment, are now reaching a moreprecise role in the world of informatics. Among the aims of a DDBsystem the following seem to have a major relevance :• To put data closer to their users .• To avoid too much resources centralization which couldcause a worsening of system efficiency and efficacy .• To enhance system reliability.• To ease data base maintenance and restructuring opera-tions while maintaining a high availability rate .• To tailor the EDP structure to the functional and organiza-tional structure of the organization.• To increase the utilization factor of EDP systems .Reaching these objectives entails the solution of a number oftechnical problems. Among them we mention:• An integrated DDB access capability.• The transparency to the user of the physical data allocation .• The logical, physical and distributive data independence .• The software portability .• An efficient cataloging system .To most of these problems, solutions have been already givenfor centralized DB, such as the data independence problem' .However, in the DDB environment the solution to this problem, aswell as to others, can be much more difficult and, even if manyproposals have been made by different researchers 2, in manycases it has not yet been attained satisfactorily. Data indepen-dence, in fact, must be assured not only at a local level, but alsowith respect to a possible data reallocation among the nodes o fthe information network.The authors are on the faculty of the lstituto de Elettrotecnica edElettronica in Milan, Italy.12