Object-relational Mapping Framework Research Articles

Comparative analysis of query execution speed using Entity Framework for selected database engines

This article presents the comparative analysis of time efficiency while executing queries by object-relational mapping framework Entity Framework for the following database engines: Microsoft SQL Server, MySQL and PostgreSQL. Time measurements of obtaining object results from database queries were made by app created in C#. Queries referred to single or multiple tables linked by relationships (1:1, 1:n, m:n) and performed operations of reading, creating, updating and deleting data. Obtained results have been cleaned from outliers and trimmed means were given as final results. Different database engines obtained the shortest query execution times depending on record number and table structures.

Demo of QueryBooster: Supporting Middleware-Based SQL Query Rewriting as a Service

Query rewriting is an important technique to optimize SQL performance in databases. With the prevalent use of business intelligence systems and object-relational mapping frameworks, existing rewriting capabilities inside databases are insufficient to optimize machine-generated queries. In this paper, we propose a novel system called "QueryBooster," to support SQL query rewriting as a cloud service. It provides a powerful and easy-to-use Web interface for users to formulate rewriting rules via a language or express rewriting intentions by providing example query pairs. It allows multiple users to share rewriting knowledge and automatically suggests shared rewriting rules for users. It requires no modifications or plugin installations to applications or databases. In this demonstration, we use real-world applications and datasets to show the user experience of QueryBooster to rewrite their application queries and share rewriting knowledge.

MODELING AND IMPLEMENTATION OF DOMAIN EVENTS IN THE DOMAIN-DRIVEN ARCHITECTURE ON THE .NET CORE PLATFORM

A software architecture centered on a domain model can provide significant advantages over other types of architectures in the long-term development and maintenance of systems with complex domain logic. At the same time, domain-driven design and approaches to software implementation of systems are relatively new concepts and continue to develop in application to various platforms, technologies and programming languages, and are of considerable interest to designers and developers. The presented work examines existing approaches to modeling and implementing domain events on the .NET Core platform in domain-driven architecture, which is one of the newest patterns. There are two approaches to implementing domain event behavior: immediate and delayed event propagation. These two approaches are analyzed and their features are described in detail. The implementation of instant propagation of domain events within a command execution transaction in the CQRS architecture is described. This implementation allows you to get rid of external dependencies, achieve purity of domain entities, as it eliminates the need to inject services, repositories in entities, and also prevents memory leaks and is safe for multithreaded use. Schematically depicts the abstract process of an external command entering a domain model, which causes a change in the state of an aggregate and the propagation of side effects with domain events. This process takes into account the capabilities of the Entity Framework object-relational mapping framework to retrieve context objects that have been changed during process. The entire stack of objects involved in this activity is located in the shared process memory, and the interaction occurs in synchronous mode. For the conceptual detection of events and aggregates, the event storming technique is used, the features of which are discussed in the article.

SLocator: Localizing the Origin of SQL Queries in Database-Backed Web Applications

In database-backed web applications, developers often leverage Object-Relational Mapping (ORM) frameworks for database accesses. ORM frameworks provide an abstraction of the underlying database access details so that developers can focus on implementing the business logic of the application. However, due to the abstraction, developers may not know where and how a problematic SQL query is generated in the application code, causing challenges in debugging database access problems. In this paper, we propose an approach, called SLocator, which locates where a SQL query is generated in the application code. SLocator is a hybrid approach that leverages both static analysis and information retrieval (IR) techniques. SLocator uses static analysis to infer the database access for every possible path in the control flow graph. Then, given a SQL query, SLocator applies IR techniques to find the control flow path (i.e., a sequence of methods called in an interprocedural control flow graph) whose inferred database access has the highest similarity ranking. We implement SLocator for Java's official ORM API specification (JPA) and evaluate SLocator on seven open source Java applications. We find that SLocator is able to locate the control flow path that generates a SQL query with a Top@1 accuracy ranging from 37.4% to 70% for SQL queries in sessions, and 30.7% to 69.2% for individual SQL queries; and Top@5 ranging from 78.3% to 95.5% for SQL queries in sessions, and 59.1% to 100% for individual SQL queries. We also conduct a study to illustrate how SLocator may be used for locating issues in the database access code.

A survey of problematic database code fragments in software systems

AbstractDatabase code fragments exist in software systems by using Structured Query Language (SQL) as the standard language for relational databases. Traditionally, developers bind databases as backends to software systems for supporting user applications. However, these bindings are low‐level code and implemented to persist user data, so Object Relational Mapping (ORM) frameworks take place to abstract database access details. Both approaches are prone to problematic database code fragments that negatively impact the quality of software systems. We survey problematic database code fragments in the literature and examine antipatterns that occur in low‐level database access code using SQL and high‐level counterparts ORM frameworks. We also study problematic database code fragments in different and popular software architectures such as Service‐Oriented Architecture, Microservice Architecture, and Model View Controller. We create a novel categorization of both SQL schema and query antipatterns in terms of performance, maintainability, portability, and data integrity.

Finding and Evaluating the Performance Impact of Redundant Data Access for Applications that are Developed Using Object-Relational Mapping Frameworks

Developers usually leverage Object-Relational Mapping (ORM) to abstract complex database accesses for large-scale systems. However, since ORM frameworks operate at a lower-level (i.e., data access), ORM frameworks do not know how the data will be used when returned from database management systems (DBMSs). Therefore, ORM cannot provide an optimal data retrieval approach for all applications, which may result in accessing redundant data and significantly affect system performance. Although ORM frameworks provide ways to resolve redundant data problems, due to the complexity of modern systems, developers may not be able to locate such problems in the code; hence, may not proactively resolve the problems. In this paper, we propose an automated approach, which we implement as a Java framework, to locate redundant data problems. We apply our framework on one enterprise and two open source systems. We find that redundant data problems exist in 87 percent of the exercised transactions. Due to the large number of detected redundant data problems, we propose an automated approach to assess the impact and prioritize the resolution efforts. Our performance assessment result shows that by resolving the redundant data problems, the system response time for the studied systems can be improved by an average of 17 percent.

ENORM

Despite the growing adoption of object-relational mapping frameworks, UML and its most widespread extensions do not represent these mappings in a platform independent way. Maintaining mappings scattered in the code is difficult and error prone, specially if the schema is large and serves several systems. This paper proposes ENORM, a notation that extends class models representing all the essential mappings. ENORM is platform independent, providing a meta-model based on design patterns employed by three frameworks of Java, Ruby, and Python languages. An empirical evaluation indicates that ENORM performs well in comparison to separated models.

Enhancing Application Performance through GORM Optimizations

GORM (Grails Object Relational Mapping) is an Object Relational Mapping Framework for the Grails web framework. Object Relational Mapping (ORM) frameworks reduce the problems arising out of the object-relational impedance mismatch between the object oriented design model and the relational database design. Unlike other ORM frameworks which require application programmers to configure a lot of XML files, GORM sits transparently between the application logic and the database relieving the programmer from maintaining any sort of configuration files. The default ORM provided by Grails through GORM introduces performance issues in a web application especially when it experiences large loads. This paper identifies problems faced when applying default GORM to application which includes the N+1 select problem, issues with handling one-to-many relationships, bulk insertions as well as problems related to bulk mail transfer and keeping the query cache unused. The paper also suggests optimization techniques which could be applied to each of the problems in order to improve the overall performance of a web application using GORM as its ORM solution. General Terms Relational Database, Object Oriented Design, Object Relational Mapping

The self-description data configuration model

ITER will consist of roughly 160 plant systems I&C delivered in kind which need to be integrated into the ITER control infrastructure. To make the integration of all these plant systems I&C, a smooth operation, the CODAC (Controls, Data Access & Communications) group release every year the core software environment which consists of many applications. In this paper we would like to describe what configuration data and how it is modeled in the version 2. The model is based on three views, the physical one which lists the components with their signals, the functional view which describes the control functions and variables required to implement them and the control view which links the two previous views. We use Hibernate as an ORM (Object Relational Mapping) framework with a PostgreSQL database and Spring as a framework to handle transactions.

Object-Relational Mapping Framework to Enable Multi-Tenancy Attributes in SaaS Applications

During the last decade, there has been a major paradigm shift in the way the software services are being provided to the enterprise and corporate sector. Instead of using on-premises LOB (Line of Business) applications, corporations and enterprises are switching to off-premises host applications that are now being offered as a service by several software companies. This new concept of providing software service is generally known as SaaS (i.e., Software as a Service). However, the adaptation of such a model necessitates that the applications - that are required to be provided as a service should be generalized for users or groups of users. The users or user groups ordinarily correspond to a company or group of companies/businesses and are termed as tenants. In this regard, the architecture of SaaS applications needs to be customized to support certain characteristics – e.g., configurability, maintainability and scalability – to support a diverse numbers of users. This paper, firstly, analyzes new trends in the present day business environment alongside the hardware and software industry that led to the development of SaaS model; and then looks into the characteristics and features that a multi-tenant system needs to possess in order to put this concept into practice.

A synergistic model-driven approach for persistence modeling with UML

The Model Driven Development (MDD) approach proposes that models (and model-to-model transformations) play the main role on system development. However, there is not a consensual notation to model persistence based upon object-relational mapping frameworks: while UML lacks specific resources for persistence modeling, the entity-relationship model does not make reference to the dynamic concepts existing in UML. This paper proposes MD-JPA, a UML profile for persistence modeling based on the well-known Java Persistence API 2 (JPA) standard for object-relational mapping, pursuing the modeling of transient and persistent elements in a more coherent and synergistic way. This paper describes the main characteristics of MD-JPA as well as the way that models that adopt such profile can them be used to generate a Java implementation by the application of the proposed model transformations on a MDD approach. Finally, an open source tool was developed to make the results of this work available to the community.

An Approach to Dynamically Operating Data Pragmatics for Internetware

网构软件不确定的数据需求导致了其数据语用(data pragmatics,简称DP)的不确定性,进而要求数据语用的支撑机制具备动态适应能力,即应用的对象属性与数据表之间的对应关系可以按需动态地创建、更新、删除.针对当前持久化技术缺乏数据语用的动态适应性问题,提出了一种基于对象/关系映射的数据语用动态支撑方法POD(persistence on demand),并且在主流ORM(object/relational mapping)框架的基础上实现了一个遵循POD的持久化框架的原型系统.;The uncertain data requirements of Internetware lead to the DP (data pragmatics) uncertainty. And then it is required that the DP operating mechanism has the ability to adapt to the uncertain DP, i.e. the corresponding relationships between application objects and database tables can be dynamically created, updated and removed on demand. As current persistence technologies lack of dynamic adaptation of DP, this paper proposes an approach to dynamically operating DP for Internetware, POD (persistence on demand), based on ORM (object/relational mapping). Together with the mainstream ORM framework, a prototype of persistence framework following POD is implemented.

ORM in Dynamic Languages

A major component of most enterprise applications is the code that transfers objects in and out of a relational database. The easiest solution is often to use an ORM (object-relational mapping) framework, which allows the developer to declaratively define the mapping between the object model and database schema and express database-access operations in terms of objects. This high-level approach significantly reduces the amount of database-access code that needs to be written and boosts developer productivity.