Integration of Object Oriented Host Program with Network DBMS

AbstractSeveral mapping techniques are in use for the storage of objects in Network Database Management System (NDBMS). Though there is a generation gap between the evolution of NDBMS and Object Oriented Technology (OOT), both are either analogous or complementary to each other. Therefore the mapping technique to map class diagram onto Bachman diagram has been evolved. Host program accessing the database and accessing the independent data file may differ in the number and use of attributes and classes. Hence along with the mapping techniques, the implementation subsets of structural and behavioral aspect are to be considered. Moreover, the persistent closure (connected dependent objects) is to be maintained during the storage and retrieval of the objects. Thus, the mere mapping technique is not sufficient for the storage and retrieval of objects as the host program has to establish the relevancy of the database with respect to its authorized subset. In this paper, we have made an attempt to develop a guidelines to assist the programmer to determine the closure of every mapped class and accordingly to design the persistent constructor and loader for the storage and retrieval of the objects respectively. The persistent closure is determined by the type of interrelationship (degree of cohesion) between objects (classes) is identified. For illustrative portion of the class diagram depicting the business process and its implementation in the NDBMS, a table containing the implemented classes with their connected classes is prepared, and then the guidelines are proposed to integrate object oriented host program to access the database through NDBMS

Transactions and schema evolution in a persistent object-oriented programming system

Applications are subject of a continuous evolution process with a profound impact on their underlining data model, hence requiring frequent updates in the applications' class structure and database structure as well. This twofold problem, schema evolution and instance adaptation, usually known as database evolution, is addressed in this thesis. Additionally, we address concurrency and error recovery problems with a novel meta-model and its aspect-oriented implementation. Modern object-oriented databases provide features that help programmers deal with object persistence, as well as all related problems such as database evolution, concurrency and error handling. In most systems there are transparent mechanisms to address these problems, nonetheless the database evolution problem still requires some human intervention, which consumes much of programmers' and database administrators' work effort. Earlier research works have demonstrated that aspect-oriented programming (AOP) techniques enable the development of flexible and pluggable systems. In these earlier works, the schema evolution and the instance adaptation problems were addressed as database management concerns. However, none of this research was focused on orthogonal persistent systems. We argue that AOP techniques are well suited to address these problems in orthogonal persistent systems. Regarding the concurrency and error recovery, earlier research showed that only syntactic obliviousness between the base program and aspects is possible. Our meta-model and framework follow an aspect-oriented approach focused on the object-oriented orthogonal persistent context. The proposed meta-model is characterized by its simplicity in order to achieve efficient and transparent database evolution mechanisms. Our meta-model supports multiple versions of a class structure by applying a class versioning strategy. Thus, enabling bidirectional application compatibility among versions of each class structure. That is to say, the database structure can be updated because earlier applications continue to work, as well as later applications that have only known the updated class structure. The specific characteristics of orthogonal persistent systems, as well as a metadata enrichment strategy within the application's source code, complete the inception of the meta-model and have motivated our research work. To test the feasibility of the approach, a prototype was developed. Our prototype is a framework that mediates the interaction between applications and the database, providing them with orthogonal persistence mechanisms. These mechanisms are introduced into applications as an {\it aspect} in the aspect-oriented sense. Objects do not require the extension of any super class, the implementation of an interface nor contain a particular annotation. Parametric type classes are also correctly handled by our framework. However, classes that belong to the programming environment must not be handled as versionable due to restrictions imposed by the Java Virtual Machine. Regarding concurrency support, the framework provides the applications with a multithreaded environment which supports database transactions and error recovery. The framework keeps applications oblivious to the database evolution problem, as well as persistence. Programmers can update the applications' class structure because the framework will produce a new version for it at the database metadata layer. Using our XML based pointcut/advice constructs, the framework's instance adaptation mechanism is extended, hence keeping the framework also oblivious to this problem. The potential developing gains provided by the prototype were benchmarked. In our case study, the results confirm that mechanisms' transparency has positive repercussions on the programmer's productivity, simplifying the entire evolution process at application and database levels. The meta-model itself also was benchmarked in terms of complexity and agility. Compared with other meta-models, it requires less meta-object modifications in each schema evolution step. Other types of tests were carried out in order to validate prototype and meta-model robustness. In order to perform these tests, we used an OO7 small size database due to its data model complexity. Since the developed prototype offers some features that were not observed in other known systems, performance benchmarks were not possible. However, the developed benchmark is now available to perform future performance comparisons with equivalent systems. In order to test our approach in a real world scenario, we developed a proof-of-concept application. This application was developed without any persistence mechanisms. Using our framework and minor changes applied to the application's source code, we added these mechanisms. Furthermore, we tested the application in a schema evolution scenario. This real world experience using our framework showed that applications remains oblivious to persistence and database evolution. In this case study, our framework proved to be a useful tool for programmers and database administrators. Performance issues and the single Java Virtual Machine concurrent model are the major limitations found in the framework

A Collection Model for Data Management in Object-Oriented Systems

This thesis addresses the question of how to provide data management services in object-oriented systems with reliable persistent object stores. It proposes an object data model, called the collection model, which serves as a foundation for the construction of such services. The collection model is general in that it is independent of any particular implementation platform. In part, this independence is achieved through the separation of the data model from the underlying type model. There are two components of the collection model - a structural model, BROOM, and an operational model based on an algebra of collections. The structural model is semantically rich and exhibits properties of both the entity-relationship and semantic data models. Hoary collections are used to represent entity categories and binary collections to represent relationships between entities. Classification structures are based on the notion of a. collection family which represents various forms of conceptual dependencies among the collections of a. family. The requirements for supporting the various forms of evolution in object-oriented database systems are presented. An extension to the collection model is proposed to support object evolution whereby objects can migrate within classification structures. Two existing realisations of the collection model are described. One is a. prototype, single-user system implemented in Prolog. The other forms the basis of the Object Data. Management Services of the Comandos platform for distributed, object-oriented applications. A general approach to object data model design, specification and realisation is advocated. In particular, a metacircular description of the collection model is used as an intermediate form of data model specification. This metacircular description is then transformed into a formal specification in the Z language

Information Integration - the process of integration, evolution and versioning

At present, many information sources are available wherever you are. Most of the time, the information needed is spread across several of those information sources. Gathering this information is a tedious and time consuming job. Automating this process would assist the user in its task. Integration of the information sources provides a global information source with all information needed present. All of these information sources also change over time. With each change of the information source, the schema of this source can be changed as well. The data contained in the information source, however, cannot be changed every time, due to the huge amount of data that would have to be converted in order to conform to the most recent schema.\ud In this report we describe the current methods to information integration, evolution and versioning. We distinguish between integration of schemas and integration of the actual data. We also show some key issues when integrating XML data sources

Designing Traceability into Big Data Systems

Providing an appropriate level of accessibility and traceability to data or process elements (so-called Items) in large volumes of data, often Cloud-resident, is an essential requirement in the Big Data era. Enterprise-wide data systems need to be designed from the outset to support usage of such Items across the spectrum of business use rather than from any specific application view. The design philosophy advocated in this paper is to drive the design process using a so-called description-driven approach which enriches models with meta-data and description and focuses the design process on Item re-use, thereby promoting traceability. Details are given of the description-driven design of big data systems at CERN, in health informatics and in business process management. Evidence is presented that the approach leads to design simplicity and consequent ease of management thanks to loose typing and the adoption of a unified approach to Item management and usage.Comment: 10 pages; 6 figures in Proceedings of the 5th Annual International Conference on ICT: Big Data, Cloud and Security (ICT-BDCS 2015), Singapore July 2015. arXiv admin note: text overlap with arXiv:1402.5764, arXiv:1402.575