76,768 research outputs found
A New Life for SQL SELECT Statement
An important percent from information systems use databases and in the majority of cases for developing such systems are used object oriented programming languages. From this point of view a key aspect is represented by the database querying features. The authors has observed a major gap between querying features of persistence mechanisms and the requirements for developing true object oriented software applications. Consequently, authors propose a new syntax for SQL SELECT statement, syntax that will allow to client applications to retrieve objects graphs.object-oriented database, query, objects graph, SQL, syntax.
Performance Analysis of Java Persistence API Providers
Nowadays, fast and accurate access to data is very important. Usually data is managed and processed through software applications. In recent years, the most preferred programming model by most application developers is Object Oriented Programming (OOP) where data is represented through objects. These data must be persistent and therefore needs to be stored, and storage can be done on a variety of databases. The most common databases are Relational Database Management Systems (RDBMS). While persistence of objects in RDBMS is limited by object-relational mismatch which is the inconsistency of the direct interaction between two components based on different approaches, OOP object on one side and RDBMS table data on the other, Object-relational mapping (ORM) can be used as a solution. ORM maps the data stored in database tables into the application objects. In other words, ORM persists data from application environment to that of the database. In this paper, we use the Java Persistence API (JPA) specification which provides the characteristics of the ORM technique for developing Java applications. A comparison of three JPA providers was performed by implementing three JPA applications in order to conclude which JPA provider has a better performance
Performance Comparison of Hibernate and EclipseLink Technologies for Mapping an Object-Oriented Model to a Relational Database
Different tiers of modern applications are built using object-oriented programming for implementing business logic and the relational database model for data storage. To solve the impendence mismatch issue that arises between the object model and relational schema, various Object-Relational Mapping (ORM) tools have been designed. In this research, the performance of two open source ORM technologies, namely Hibernate and EclipseLink, is investigated. Hibernate is a well established middleware solution while EclipseLink, which stems from Oracleâs TopLink, is a new product on the persistence landscape. For the purpose of this research, a web-based application was developed and used as a test system. The performance test facilities were integrated into design of the application. The abstract layer introduced into applicationâs architecture with the Spring Data Access Object (DAO), made the system highly modular allowing easily switching between persistence technologies with no alterations in the rest of the application code
Object Management for Persistence and Recoverability
PhD ThesisAs distribution becomes commonplace, there is a growing requirement for
applications that behave reliably when node or network failures occur. To
support reliability, operations on the components of a distributed application may
be declared to occur within the scope of an atomic action. This thesis describes
how atomic actions may be supported in an environment consisting of
applications that operate on objects.
To support the failure atomicity and permanence of effect properties of an
atomic action, the objects accessed within the scope of an atomic action must be
recoverable and persistent. This thesis describes how these properties may be
added to the class of an object. The approach adopted is to provide a class that
implements recovery and persistence mechanisms, and derive new classes from
this base class. By refining inherited operations so that recovery and persistence
is specific to that class, recoverable and persistent objects may be easily produced.
This thesis also describes how an atomic action may be implemented as a
class, so that instances of the class are atomic actions which manage the
recoverable and persistent objects. Multiple instance declarations produce nested
atomic actions, and the atomic action class also inherits persistence so that shortterm
commit information may be saved in an object store which is used to
maintain the passive state of persistent objects.
Since the mechanisms and classes that support recovery, persistence, and
atomic actions are constructed using the feature of an object-oriented language,
they may be implemented in environments that provide suitable support for
objects and object-oriented programming languages.Science and
Engineering Research Council,
SERC/Alve
Towards a flexible and transparent database evolution
Applications refactorings that imply the schema evolution are common activities in programming practices. Although modern object-oriented databases provide transparent schema evolution mechanisms, those refactorings continue to be time consuming tasks for programmers.
In this paper we address this problem with a novel approach based on aspect-oriented programming and orthogonal persistence paradigms, as well as our meta-model.
An overview of our framework is presented. This framework, a prototype based on that approach, provides applications with aspects of persistence and database evolution. It also provides a new pointcut/advice language that enables the modularization of the instance adaptation crosscutting concern of classes, which were subject to a schema evolution.
We also present an application that relies on our framework. This application was developed without any concern regarding persistence and database evolution. However, its data is recovered in each execution, as well as objects, in previous schema versions, remain available, transparently, by means of our framework
Modularizing application and database evolution - an aspect-oriented framework for orthogonal persistence
In the maintenance of software applications, database evolution is one common difficulty. In objectâoriented databases, this process comprises schema evolution and instance adaptation. Both tasks usually require significant effort from programmers and database administrators. In this paper, we propose orthogonal persistence and aspectâoriented programming to support semiâtransparent database evolution. A default mechanism for instance evolution is defined, but the user may provide modularized solutions using the aspectâoriented paradigm. We present our framework AOF4OOP to test the feasibility of our proposed approach. This prototype allows programmes to transparently access data in other versions of the database schema. We evaluate our framework, comparing it to related approaches using two real applications and measuring the improvement of the productivity of the programmer.info:eu-repo/semantics/publishedVersio
Object-Relational Mapping as a Persistence Mechanism for Object-Oriented Applications
Many object-oriented applications created today, especially Web applications, use relational databases for persistence. Often there is a straightforward correspondence between database tables on the one hand and application classes on the other. Application developers usually write a great deal of code to connect to and query the database, code which differs little from class to class and is often tedious to write. Moreover, the parallel class and table structures constitute a duplication of information, which requires duplication of work and increases the likelihood of errors. Ideally, we could automate this duplication, rendering it invisible to developers. This is the idea behind object-relational mapping (ORM), which achieves the mapping between the object-oriented world and the relational world automatically. Many existing ORM tools do not realize the goal of fully transparent persistence, however, and ORM tools have not become pervasive in the software industry. We survey ORM technology, probing issues of ORM system architecture and examining real-world ORM systems. We consider the state of the art in ORM, asking why it is not more popular than it is and anticipating the future course of ORM system development
An aspect-oriented framework for orthogonal persistence
The life cycle of software applications in general is very short and with extreme volatile requirements. Within these conditions programmers need development tools and techniques with an extreme level of productivity. We consider the code reuse as the most prominent approach to solve that problem. Our proposal uses the advantages provided by the Aspect-Oriented Programming in order to build a reusable framework capable to turn both programmer and application oblivious as far as data persistence is concerned, thus avoiding the need to write any line of code about that concern. Besides the benefits to productivity, the software quality increases. This paper describes the actual state of the art, identifying the main challenge to build a complete and reusable framework for Orthogonal Persistence in concurrent environments with support for transactions. The present work also includes a successfully developed prototype of that framework, capable of freeing the programmer of implementing any read or write data operations. This prototype is supported by an object oriented database and, in the future, will also use a relational database and have support for transactions
- âŠ