Wrapper-based Evolution of Legacy Information Systems

Philippe Thiran, Jean-Luc Hainaut, Geert-Jan Houben, Djamal Benslimane

Research output: Contribution to journalArticle

Abstract

System evolution most often implies the integration of legacy components, such as databases, with newly developed ones, leading to mixed architectures that suffer from severe heterogeneity problems. For instance, incorporating a new program in a legacy database application can create an integrity mismatch, since the database model and the program data view can be quite different (e.g. standard file model versus OO model). In addition, neither the legacy DBMS (too weak to address integrity issues correctly) nor the new program (that relies on data server responsibility) correctly cope with data integrity management. The component that can reconciliate these mismatched subsystems is the R/W wrapper, which allows any client program to read, but also to update the legacy data, while controlling the integrity constraints that are ignored by the legacy DBMS. The paper describes a generic, technology-independent, R/W wrapper architecture, a methodology for specifying them in a disciplined way, and a CASE tool for generating most of the corresponding code. The key concept is that of implicit construct, which is a structure or a constraint that has not been declared in the database, but which is controlled by the legacy application code. The implicit constructs are elicited through reverse engineering techniques, and then translated into validation code in the wrapper. For instance, a wrapper can be generated for a collection of COBOL files in order to allow external programs to access them through a relational, object-oriented or XML interface, while offering referential integrity control. The methodology is based on a transformational approach that provides a formal way to build the wrapper schema and to specify inter-schema mappings.
Original languageEnglish
Pages (from-to)329-359
Number of pages31
JournalACM Transactions on Software Engineering and Methodology (TOSEM)
Volume15
Issue number4
Publication statusPublished - 2006

Fingerprint

Information systems
Reverse engineering
XML
Servers

Keywords

  • Data consistency
  • Evolution
  • Wrapper
  • Data reverse-engineering
  • Schema transformation
  • Legacy database
  • CASE tool

Cite this

@article{b4a561c0ae6644ba974e88e2b364fdc0,
title = "Wrapper-based Evolution of Legacy Information Systems",
abstract = "System evolution most often implies the integration of legacy components, such as databases, with newly developed ones, leading to mixed architectures that suffer from severe heterogeneity problems. For instance, incorporating a new program in a legacy database application can create an integrity mismatch, since the database model and the program data view can be quite different (e.g. standard file model versus OO model). In addition, neither the legacy DBMS (too weak to address integrity issues correctly) nor the new program (that relies on data server responsibility) correctly cope with data integrity management. The component that can reconciliate these mismatched subsystems is the R/W wrapper, which allows any client program to read, but also to update the legacy data, while controlling the integrity constraints that are ignored by the legacy DBMS. The paper describes a generic, technology-independent, R/W wrapper architecture, a methodology for specifying them in a disciplined way, and a CASE tool for generating most of the corresponding code. The key concept is that of implicit construct, which is a structure or a constraint that has not been declared in the database, but which is controlled by the legacy application code. The implicit constructs are elicited through reverse engineering techniques, and then translated into validation code in the wrapper. For instance, a wrapper can be generated for a collection of COBOL files in order to allow external programs to access them through a relational, object-oriented or XML interface, while offering referential integrity control. The methodology is based on a transformational approach that provides a formal way to build the wrapper schema and to specify inter-schema mappings.",
keywords = "Data consistency, Evolution, Wrapper, Data reverse-engineering, Schema transformation, Legacy database, CASE tool",
author = "Philippe Thiran and Jean-Luc Hainaut and Geert-Jan Houben and Djamal Benslimane",
year = "2006",
language = "English",
volume = "15",
pages = "329--359",
journal = "ACM Transactions on Software Engineering and Methodology (TOSEM)",
issn = "1049-331X",
publisher = "ACM Press",
number = "4",

}

Wrapper-based Evolution of Legacy Information Systems. / Thiran, Philippe; Hainaut, Jean-Luc; Houben, Geert-Jan; Benslimane, Djamal.

In: ACM Transactions on Software Engineering and Methodology (TOSEM), Vol. 15, No. 4, 2006, p. 329-359.

Research output: Contribution to journalArticle

TY - JOUR

T1 - Wrapper-based Evolution of Legacy Information Systems

AU - Thiran, Philippe

AU - Hainaut, Jean-Luc

AU - Houben, Geert-Jan

AU - Benslimane, Djamal

PY - 2006

Y1 - 2006

N2 - System evolution most often implies the integration of legacy components, such as databases, with newly developed ones, leading to mixed architectures that suffer from severe heterogeneity problems. For instance, incorporating a new program in a legacy database application can create an integrity mismatch, since the database model and the program data view can be quite different (e.g. standard file model versus OO model). In addition, neither the legacy DBMS (too weak to address integrity issues correctly) nor the new program (that relies on data server responsibility) correctly cope with data integrity management. The component that can reconciliate these mismatched subsystems is the R/W wrapper, which allows any client program to read, but also to update the legacy data, while controlling the integrity constraints that are ignored by the legacy DBMS. The paper describes a generic, technology-independent, R/W wrapper architecture, a methodology for specifying them in a disciplined way, and a CASE tool for generating most of the corresponding code. The key concept is that of implicit construct, which is a structure or a constraint that has not been declared in the database, but which is controlled by the legacy application code. The implicit constructs are elicited through reverse engineering techniques, and then translated into validation code in the wrapper. For instance, a wrapper can be generated for a collection of COBOL files in order to allow external programs to access them through a relational, object-oriented or XML interface, while offering referential integrity control. The methodology is based on a transformational approach that provides a formal way to build the wrapper schema and to specify inter-schema mappings.

AB - System evolution most often implies the integration of legacy components, such as databases, with newly developed ones, leading to mixed architectures that suffer from severe heterogeneity problems. For instance, incorporating a new program in a legacy database application can create an integrity mismatch, since the database model and the program data view can be quite different (e.g. standard file model versus OO model). In addition, neither the legacy DBMS (too weak to address integrity issues correctly) nor the new program (that relies on data server responsibility) correctly cope with data integrity management. The component that can reconciliate these mismatched subsystems is the R/W wrapper, which allows any client program to read, but also to update the legacy data, while controlling the integrity constraints that are ignored by the legacy DBMS. The paper describes a generic, technology-independent, R/W wrapper architecture, a methodology for specifying them in a disciplined way, and a CASE tool for generating most of the corresponding code. The key concept is that of implicit construct, which is a structure or a constraint that has not been declared in the database, but which is controlled by the legacy application code. The implicit constructs are elicited through reverse engineering techniques, and then translated into validation code in the wrapper. For instance, a wrapper can be generated for a collection of COBOL files in order to allow external programs to access them through a relational, object-oriented or XML interface, while offering referential integrity control. The methodology is based on a transformational approach that provides a formal way to build the wrapper schema and to specify inter-schema mappings.

KW - Data consistency

KW - Evolution

KW - Wrapper

KW - Data reverse-engineering

KW - Schema transformation

KW - Legacy database

KW - CASE tool

M3 - Article

VL - 15

SP - 329

EP - 359

JO - ACM Transactions on Software Engineering and Methodology (TOSEM)

JF - ACM Transactions on Software Engineering and Methodology (TOSEM)

SN - 1049-331X

IS - 4

ER -