Towards a safe method for computing dependencies in database-intensive systems

Csaba Nagy, János Pántos, Tamás Gergely, A. Beszédes

Research output: Chapter in Book/Report/Conference proceedingConference contribution

4 Citations (Scopus)

Abstract

Determining dependencies between different components of an application is useful in lots of applications (e. g., architecture reconstruction, reverse engineering, regression test case selection, change impact analysis). However, implementing automated methods to recover dependencies has many challenges, particularly in systems using databases, where dependencies may arise via database access. Furthermore, it is especially hard to find safe techniques (which do not omit any important dependency) that are applicable to large and complex systems at the same time. We propose two techniques that can cope with these problems in most situations. These methods compute dependencies between procedures or database tables, and they are based on the simultaneous static analysis of the source code, the database schema and the SQL instructions. In this paper, we quantitatively and qualitatively evaluate the methods on real-life data, and also evaluate them on some of their potential applications.

Original languageEnglish
Title of host publicationProceedings of the European Conference on Software Maintenance and Reengineering, CSMR
Pages166-175
Number of pages10
DOIs
Publication statusPublished - 2011
Event14th European Conference on Software Maintenance and Reengineering, CSMR 2010 - Madrid, Spain
Duration: Mar 15 2010Mar 18 2010

Other

Other14th European Conference on Software Maintenance and Reengineering, CSMR 2010
CountrySpain
CityMadrid
Period3/15/103/18/10

Fingerprint

Reverse engineering
Static analysis
Large scale systems

Keywords

  • CRUD matrix
  • Databases
  • Program analysis
  • Program dependencies
  • SEA relations

ASJC Scopus subject areas

  • Software

Cite this

Nagy, C., Pántos, J., Gergely, T., & Beszédes, A. (2011). Towards a safe method for computing dependencies in database-intensive systems. In Proceedings of the European Conference on Software Maintenance and Reengineering, CSMR (pp. 166-175). [5714431] https://doi.org/10.1109/CSMR.2010.29

Towards a safe method for computing dependencies in database-intensive systems. / Nagy, Csaba; Pántos, János; Gergely, Tamás; Beszédes, A.

Proceedings of the European Conference on Software Maintenance and Reengineering, CSMR. 2011. p. 166-175 5714431.

Research output: Chapter in Book/Report/Conference proceedingConference contribution

Nagy, C, Pántos, J, Gergely, T & Beszédes, A 2011, Towards a safe method for computing dependencies in database-intensive systems. in Proceedings of the European Conference on Software Maintenance and Reengineering, CSMR., 5714431, pp. 166-175, 14th European Conference on Software Maintenance and Reengineering, CSMR 2010, Madrid, Spain, 3/15/10. https://doi.org/10.1109/CSMR.2010.29
Nagy C, Pántos J, Gergely T, Beszédes A. Towards a safe method for computing dependencies in database-intensive systems. In Proceedings of the European Conference on Software Maintenance and Reengineering, CSMR. 2011. p. 166-175. 5714431 https://doi.org/10.1109/CSMR.2010.29
Nagy, Csaba ; Pántos, János ; Gergely, Tamás ; Beszédes, A. / Towards a safe method for computing dependencies in database-intensive systems. Proceedings of the European Conference on Software Maintenance and Reengineering, CSMR. 2011. pp. 166-175
@inproceedings{47f0cb5a53264a5ca7c60f120956f129,
title = "Towards a safe method for computing dependencies in database-intensive systems",
abstract = "Determining dependencies between different components of an application is useful in lots of applications (e. g., architecture reconstruction, reverse engineering, regression test case selection, change impact analysis). However, implementing automated methods to recover dependencies has many challenges, particularly in systems using databases, where dependencies may arise via database access. Furthermore, it is especially hard to find safe techniques (which do not omit any important dependency) that are applicable to large and complex systems at the same time. We propose two techniques that can cope with these problems in most situations. These methods compute dependencies between procedures or database tables, and they are based on the simultaneous static analysis of the source code, the database schema and the SQL instructions. In this paper, we quantitatively and qualitatively evaluate the methods on real-life data, and also evaluate them on some of their potential applications.",
keywords = "CRUD matrix, Databases, Program analysis, Program dependencies, SEA relations",
author = "Csaba Nagy and J{\'a}nos P{\'a}ntos and Tam{\'a}s Gergely and A. Besz{\'e}des",
year = "2011",
doi = "10.1109/CSMR.2010.29",
language = "English",
isbn = "9780769543215",
pages = "166--175",
booktitle = "Proceedings of the European Conference on Software Maintenance and Reengineering, CSMR",

}

TY - GEN

T1 - Towards a safe method for computing dependencies in database-intensive systems

AU - Nagy, Csaba

AU - Pántos, János

AU - Gergely, Tamás

AU - Beszédes, A.

PY - 2011

Y1 - 2011

N2 - Determining dependencies between different components of an application is useful in lots of applications (e. g., architecture reconstruction, reverse engineering, regression test case selection, change impact analysis). However, implementing automated methods to recover dependencies has many challenges, particularly in systems using databases, where dependencies may arise via database access. Furthermore, it is especially hard to find safe techniques (which do not omit any important dependency) that are applicable to large and complex systems at the same time. We propose two techniques that can cope with these problems in most situations. These methods compute dependencies between procedures or database tables, and they are based on the simultaneous static analysis of the source code, the database schema and the SQL instructions. In this paper, we quantitatively and qualitatively evaluate the methods on real-life data, and also evaluate them on some of their potential applications.

AB - Determining dependencies between different components of an application is useful in lots of applications (e. g., architecture reconstruction, reverse engineering, regression test case selection, change impact analysis). However, implementing automated methods to recover dependencies has many challenges, particularly in systems using databases, where dependencies may arise via database access. Furthermore, it is especially hard to find safe techniques (which do not omit any important dependency) that are applicable to large and complex systems at the same time. We propose two techniques that can cope with these problems in most situations. These methods compute dependencies between procedures or database tables, and they are based on the simultaneous static analysis of the source code, the database schema and the SQL instructions. In this paper, we quantitatively and qualitatively evaluate the methods on real-life data, and also evaluate them on some of their potential applications.

KW - CRUD matrix

KW - Databases

KW - Program analysis

KW - Program dependencies

KW - SEA relations

UR - http://www.scopus.com/inward/record.url?scp=79952635903&partnerID=8YFLogxK

UR - http://www.scopus.com/inward/citedby.url?scp=79952635903&partnerID=8YFLogxK

U2 - 10.1109/CSMR.2010.29

DO - 10.1109/CSMR.2010.29

M3 - Conference contribution

AN - SCOPUS:79952635903

SN - 9780769543215

SP - 166

EP - 175

BT - Proceedings of the European Conference on Software Maintenance and Reengineering, CSMR

ER -