Ssql-Schema-Comparer: Support of Multi-Language Refactoring With
Total Page:16
File Type:pdf, Size:1020Kb
2013 IEEE 13th International Working Conference on Source Code Analysis and Manipulation (SCAM) sql-schema-comparer: Support of Multi-Language Refactoring with Relational Databases Hagen Schink Institute of Technical and Business Information Systems Otto-von-Guericke-University Magdeburg, Germany [email protected] Abstract—Refactoring is a method to change a source-code’s State-of-the-art IDEs provide information about syntactical structure without modifying its semantics and was first intro- changes or errors before integration or runtime tests take duced for object-oriented code. Since then refactorings were effect. Hence, the information can enable software developers defined for relational databases too. But database refactorings must be treated differently because a database schema’s structure to recognize and correct syntactic and some semantic errors defines semantics used by other applications to access the data already during development. We argue that information about in the schema. Thus, many database refactorings may break syntactical changes in database schemes can ease the problems interaction with other applications if not treated appropriately. of database refactoring. We discuss problems of database refactoring in regard to Java In the following we first present two techniques for ac- code and present sql-schema-comparer, a library to detect refac- torings of database schemes. The sql-schema-comparer library cessing a relational database with the programming language is our first step to more advanced tools supporting developers in Java. Then, we describe how database refactoring affects their database refactoring efforts. database access from Java. In Sec. III we give a more general explanation of problems resulting from database refactorings. I. INTRODUCTION Furthermore, we propose an approach to automatically detect database schema modifications affecting database interaction Relational databases provide sophisticated functions for data and present the sql-schema-comparer library that implements persistence and retrieval [1]. In relational databases, data tool support for our approach. In Sec. IV we present related is stored according to a relational schema [2]. A relational work before we conclude our work and present our future schema predefines the logical structure of data. plans for the sql-schema-comparer library in Sec. V and Software applications are subject to change because of Sec. VI. changing requirements and business conditions. However, adapting software applications may also require the adaption II. DATABASE INTERACTION AND REFACTORING of the relational schema and vice versa. In this section we explain how data is retrieved from a Refactoring is a methodology to transform source code relational database using the programming language Java. We in such a way that the source-code’s functionality is pre- also explain how changes of the relational schema affect the served [3]. Refactorings are specific code transformations and interaction between Java code and databases. were first defined for object-oriented source code. But refac- torings exist for relational databases too [4], [5]. Relational A. Examples of Database Interaction in Java refactorings enable developers and database administrators to We consider two approaches to database interaction with improve the structure of a relational schema without changing Java: (1) a direct approach utilizing SQL statements and (2) the informational semantics of the relational schema. Thus, a an abstracted approach utilizing an object-relational mapper. relational schema provides the same information before and The following examples are based upon two representatives of after a relational refactoring. these approaches: (1) the Java Database Connectivity (JDBC) Different APIs for many programming language exist to and (2) the Java Persistence API (JPA). access relational databases. However, how APIs access data 1) Direct Database Interaction with JDBC: With JDBC in the relational database depends on the structure defined by developers define database requests with SQL. In JDBC a the relational schema. Thus, if the relational schema changes, database query returns an object of type ResultSet rep- e.g. because of refactoring, database access may be broken. resenting the SQL query result. Listing 1 presents a possible Broken database access may only be noticed by integration definition of a query that retrieves all first names of employees tests or at runtime. starting with the letter M. 164 2013 IEEE 13th International Working Conference on Source Code Analysis and Manipulation (SCAM) discussion concise, we focus only on two database refactor- Listing 1: JDBC: Parameterized query for first names ings, namely the Split Column Refactoring and the Introduce 1 String stmt = ”SELECT firstname FROM employees ” Column Constraint Refactoring. 2 + ”WHERE firstname LIKE ?”; 1) Split Column Refactoring: The purpose of the Split Col- 3 PreparedStatement query = con.prepareStatement(stmt); 4 umn Refactoring is to separate information that is combined 5 query.setString(1, ”M%”); in one table column. Let’s assume we have a database column 6 ResultSet result = query.executeQuery(); amount storing an amount of money and its currency. We want to split the column into two columns amount and currency to make queries for the currency easier. Existing JDBC queries like in Listing 3 need to be adapted because Listing 2: Annotated class Department the column amount does not hold any currency information 1 @Entity after refactoring. A possible adaption is given in Listing 4. 2 @Table(name=”departments”) With JPA, we need to extend the ORM to map to the new 3 public class Department implements Serializable { column currency. Therefor, we need a new getter/setter 4 5 /∗ Snip ∗/ pair, e.g. getCurrency/setCurrency. 6 7 private int id; 8 private String name; Listing 3: Query accounts by currency 9 1 SELECT amount FROM accounts 10 public void setId(int id) { this.id = id; } 2 WHERE amount LIKE ’%EUR’; 11 12 @Id 13 public int getId() { return id; } Listing 4: Modified query for accounts by currency 14 15 public void setName(String name) { this.name = name; } 1 SELECT currency FROM accounts 16 2 WHERE currency = ’EUR’; 17 public String getName() { return name; } 18 } 2) Introduce Column Constraint Refactoring: The purpose of the Introduce Column Constraint Refactoring is to define a new column constraint to increase data quality. Let’s assume Because of missing abstraction, JDBC requires detailed we have a database table accounts with a column named knowledge about the relational schema. For instance, in List- type. The column type distinguishes different kinds of ing 1 Line 5, the passed parameter must be an instance of accounts by an uppercase letter. To ensure that only valid class String because column firstname stores characters. types are stored in table account, we can apply a column Thus, a software developer must enforce type correctness. constraint like in Listing 5. 2) Abstracted Database Interaction with JPA: JPA pro- vides means to define a mapping between relational tables Listing 5: CHECK constraint on column type and object-oriented classes. This mapping is called object- relational mapping (ORM). Thus, in contrast to JDBC, de- 1 ’type’ text CHECK(type = ’A’ OR type = ’B’ OR type = ’C’) velopers receive objects instead of plain data from a relational database. A column constraint helps users with direct database access Listing 2 shows an implementation of a class representing to preserve data quality. But applications accessing a table with a department. In JPA, each class annotated with @Entity constraints may not know about the restrictions enforced by becomes part of the ORM, thus, class properties are mapped the constraints. Such applications and their users are not able upon columns in the mapped relational table. Hence, regarding to handle the column constraints adequately. Developers of Listing 2, we expect a table departments (Line 2) with such applications may have to adapt the user interface and the the two columns id (Line 10 and 13) and name (Line 15 applications database access to allow only such account types 1 and 17) . introduced by the Introduce Column Constraint Refactoring. Thus, the introduction of a column constraint by a refactoring B. Database Refactoring and Interaction may result in considerable effort to adapt related applications The Database Refactoring website lists 69 database refac- independent of the kind of database interaction. 2 torings. In the following we give examples on how database III. SEMANTICS-PRESERVATION IN DATABASES refactorings affect database interaction. To keep the following In Sec. II-B, we showed that a database refactoring may result in considerable effort to adapt interacting software appli- 1Because method getId() (Line 13) is annotated with @Id, JPA uses property access. Thus, columns are defined by getter/setter pairs. cations. We argue that this is the result of different meanings of 2http://databaserefactoring.com/, 03/23/2013 semantics-preservation for software applications and database 165 2013 IEEE 13th International Working Conference on Source Code Analysis and Manipulation (SCAM) schemes. This difference of semantics-preservation originates non-existing constraints. The third condition points to issues from a different semantics idea that is expressed in the term after data format alignment: If the data format is changed, an informational semantics [4]. application may not be able to process a new format, although