LIBD:Themes:Database-Languages-and-API - Historique des versions

Dbm le 19 décembre 2010 à 17:20

2010-12-19T17:20:40Z

Dbm le 16 décembre 2010 à 19:13

2010-12-16T19:13:44Z

Dbm le 16 décembre 2010 à 18:47

2010-12-16T18:47:18Z

Modifications en cours

Dbm le 16 décembre 2010 à 18:42

2010-12-16T18:42:57Z

Dbm le 16 décembre 2010 à 12:04

2010-12-16T12:04:18Z

Dbm le 16 décembre 2010 à 11:45

2010-12-16T11:45:10Z

Dbm le 16 décembre 2010 à 11:38

2010-12-16T11:38:36Z

Dbm le 15 décembre 2010 à 14:29

2010-12-15T14:29:51Z

Dbm le 13 décembre 2010 à 16:55

2010-12-13T16:55:19Z

Dbm le 13 décembre 2010 à 16:42

2010-12-13T16:42:28Z

@@ Ligne 92 : / Ligne 92 : @@
 :'''[P96-01]''' Jean Henrard, Jean-Marc Hick, Didier Roland, Vincent Englebert and Jean-Luc Hainaut. <u>Techniques d’analyse de programmes pour la rétro-ingénierie de bases de données</u>, in ''Actes du XIV Congrès INFORSID'', pages 215-232, Edit. AFCET, 1996. [http://www.fundp.ac.be/recherche/publications/page_view/37766/ [description]] [http://www.info.fundp.ac.be/~dbm/Documents/Publications-LIBD/Articles-Conferences/conferences-INFORSID/INFORSID-1996/Inforsid-1996.pdf [full text]]
-:[B94] Jean-Luc Hainaut. Bases de données et modèles de calcul - Outils et méthodes pour l'utilisateur, InterEditions (Dunod), Paris, 1994. [http://info.fundp.ac.be/~dbm/mediawiki/index.php/INTEREDITION1994 | [book description]]
+:'''[B94]''' Jean-Luc Hainaut. ''Bases de données et modèles de calcul - Outils et méthodes pour l'utilisateur'', InterEditions (Dunod), Paris, 1994. [http://info.fundp.ac.be/~dbm/mediawiki/index.php/INTEREDITION1994 | [book description]]
 :'''[P90-02]''' Jean-Luc Hainaut. <u>Systèmes d’aide à la décision : une approche méthodologique intégrée</u>, in ''Actes du congrès INFORSID 1990'', pages 7-34, Eyrolles-Afcet, 1990. [http://www.fundp.ac.be/recherche/publications/page_view/41406/ [description]] [http://www.info.fundp.ac.be/~dbm/Documents/Publications-LIBD/Articles-Conferences/conferences-INFORSID/INFORSID-1990/INFORSID-1990.pdf [full text]].

@@ Ligne 35 : / Ligne 35 : @@
 :*<b>Conceptual API for system evolution</b> (''API''). The fast evolution of applications systems forces developers to adopt defensive programing techniques to facilitate system adaptation. We have developed a Java API that offers data manipulation at the conceptual level (according to a variant of the Entity-relationship model). The API is automatically generated by the DB-MAIN CASE tool according to rules that minimize the impact of changes on the database, on the data and on the application programs [P10-05].
-:*<b>Languages for CASE tools</b>. As any high-end CASE tool, the DB-MAIN environment allows users to develop new functions (checkers, code/report generators, reasoners, etc.) A first language, Voyager 2, was developed in 1995. This complete procedural language provides declarative statements to access the DB-MAIN repository (the database in which DB-MAIN stores the projects, schemas and other products it manages). Later on, ReveR (the spin-off of the LIBD in charge of the maintenance and evolution of the tool) included a JVM (Java virtual machine) into the tool to allow java plug-ins to be developed as well [DB-MAIN]. In parallel, a new research was conducted on generic CASE tool architectures. The proposal comprised three languages, namely a concept definition language, a procedural language and a graphical language (GRASYLA) [P99-03] [P99-06] [PHD00]. The research is ongoing through the development of the Metadone metaCASE tool.
+:*<b>Languages for CASE tools</b>. As any high-end CASE tool, the DB-MAIN environment allows users to develop new functions (checkers, code/report generators, reasoners, etc.) A first language, Voyager 2, was developed in 1995. This complete procedural language provides declarative statements to access the DB-MAIN repository (the database in which DB-MAIN stores the projects, schemas and other products it manages). Later on, ReveR (the spin-off of the LIBD in charge of the maintenance and evolution of the tool) included a JVM (Java virtual machine) into the tool to allow java plug-ins to be developed as well [DB-MAIN]. In parallel, a new research was conducted on generic CASE tool architectures. The proposal comprised three languages, namely a concept definition language, a procedural language and a graphical language (GRASYLA) [P99-03] [P99-06] [PHD00]. The research is ongoing through the development of the METADONE metaCASE tool.
 :*<b>Co-transformation</b> (''language processing''). Current studies on software intensive system evolution emphasize the concept of co-transformation. When two artefacts A and B interact (e.g., program B working on database A), modifying A may imply modifying B accordingly. If changes to A can be modeled by transformations, the adaptation of B can, under specific conditions, be carried out automatically. The coordinated modification of A and B is called ''co-transformation''.  The idea was first suggested in [B86] to automatically transform ADL algorithms defined on a conceptual schema into algorithms compliant with a logical model such as SQL, standard file structure or CODASYL. More recently, co-transformations were studied in the context of data intensive system evolution. The problem addressed is the following. We consider, as a case study, a legacy database that is to migrate to a modern platform. The best approach consists in reverse engineering the legacy database in order to get its conceptual schema, then to generate a new database according to the new data model. Then the legacy data are transformed and moved to the new database and, finally, the application programs are adapted to the new schema and the new API. The whole process can be described as a co-transformation of schema, data and programs, driven by schema transformation. In this process, program transformation is particularly challenging. The problem is described in [P04-03], [P06-04] and [P06-06], an application in [P08-05] and the full solution, including the use of ASF/SDF for program transformation, in [PHD09].

@@ Ligne 12 : / Ligne 12 : @@
 ::#''language processing'': co-transformation, program analysis
-:*<b>Data Access Description Language (ADL)</b> (''abstract language''). The ADL language, borrowed from the IDML interface, has been used as an abstract data manipulation language to describe database algorithms. Formely a companion language of the GAM (notably to study performance of database programs [P76-02] [P77-01]), it has been extended recently to complement the GER in A. Cleves’s thesis [PHD09]. In book [B86], ADL was used to describe abstract database programs in a logical database design process. The latter book also describes ADL transformations following data structure transformations (what will be called later co-transformations). This framework allows programs to be described at the conceptual level, then to be automatically transformed into algorithms compliant with logical database schemas.
+:*<b>Data Access Description Language (ADL)</b> (''abstract language''). The ADL language, borrowed from the IDML interface, has been used as an abstract data manipulation language to describe database algorithms. Formely a companion language of the GAM (notably to study performance of database programs [P76-02] [P77-01]), it has been extended recently to complement the GER in A. Cleves’s thesis [PHD09]. In book [B86], ADL was used to describe abstract database programs in a logical database design process. The latter book also describes ADL transformations following data structure transformations (what will be called later co-transformations). This framework allows programs to be described at the conceptual level, then to be automatically transformed into algorithms compliant with logical database schemas.  ADL has also been used as the basis for the rule language of the decision support data model [P90-02] and [B94].
 :*<b>SPHINX DDL and DML</b> (''DBMS languages''). One of results of the project Large Administrative Databases (1971-1977) was a DBMS based on a Entity-relationship model. It included a data definition language and a data manipulation language for COBOL programs [P78-01] [P78-03]. A detailed specification of these languages can be found in the final report of the project ([R78-01] to [R79-05]).

@@ Ligne 35 : / Ligne 35 : @@
 :*<b>Conceptual API for system evolution</b> (''API''). The fast evolution of applications systems forces developers to adopt defensive programing techniques to facilitate system adaptation. We have developed a Java API that offers data manipulation at the conceptual level (according to a variant of the Entity-relationship model). The API is automatically generated by the DB-MAIN CASE tool according to rules that minimize the impact of changes on the database, on the data and on the application programs [P10-05].
-:*<b>Languages for CASE tools</b>. [DB-MAIN] [P99-03] [P99-06] [PHD00]
+:*<b>Languages for CASE tools</b>. As any high-end CASE tool, the DB-MAIN environment allows users to develop new functions (checkers, code/report generators, reasoners, etc.) A first language, Voyager 2, was developed in 1995. This complete procedural language provides declarative statements to access the DB-MAIN repository (the database in which DB-MAIN stores the projects, schemas and other products it manages). Later on, ReveR (the spin-off of the LIBD in charge of the maintenance and evolution of the tool) included a JVM (Java virtual machine) into the tool to allow java plug-ins to be developed as well [DB-MAIN]. In parallel, a new research was conducted on generic CASE tool architectures. The proposal comprised three languages, namely a concept definition language, a procedural language and a graphical language (GRASYLA) [P99-03] [P99-06] [PHD00]. The research is ongoing through the development of the Metadone metaCASE tool.
 :*<b>Co-transformation</b> (''language processing''). Current studies on software intensive system evolution emphasize the concept of co-transformation. When two artefacts A and B interact (e.g., program B working on database A), modifying A may imply modifying B accordingly. If changes to A can be modeled by transformations, the adaptation of B can, under specific conditions, be carried out automatically. The coordinated modification of A and B is called ''co-transformation''.  The idea was first suggested in [B86] to automatically transform ADL algorithms defined on a conceptual schema into algorithms compliant with a logical model such as SQL, standard file structure or CODASYL. More recently, co-transformations were studied in the context of data intensive system evolution. The problem addressed is the following. We consider, as a case study, a legacy database that is to migrate to a modern platform. The best approach consists in reverse engineering the legacy database in order to get its conceptual schema, then to generate a new database according to the new data model. Then the legacy data are transformed and moved to the new database and, finally, the application programs are adapted to the new schema and the new API. The whole process can be described as a co-transformation of schema, data and programs, driven by schema transformation. In this process, program transformation is particularly challenging. The problem is described in [P04-03], [P06-04] and [P06-06], an application in [P08-05] and the full solution, including the use of ASF/SDF for program transformation, in [PHD09].

@@ Ligne 20 : / Ligne 20 : @@
 :*<b>IDML</b> (''DBMS languages''). Based on the experience of system SPHINX, we experimented wrapper technology to interface application programs with CODASYL databases through a high-level neutral data manipulation language based on a binary data model (1978-1981). This language will be reused later under the name ADL. A prototype wrapper generator was developed [P78-02] [P81-01].
-:*<b>NDBS</b> (''DBMS languages''). NDBS (Network Database System, 1986-1996) is an educational database management environment allowing Turbo-Pascal programs to manage and use complex data in an efficient, though very intuitive, way. NDBS comprised a runtime library (database handler), a DDL compiler, a 4GL Query Language, a data dictionary, a report generator, a SQL/NDBS converter, an import/export tool, etc. The last version (under the name Pyramid) was developed by D. Rossi, then Master student in the University of Namur. Two original aspects: (1) the data model was a variant of the ER model, (2) the physical engine was a fairly strict implementation of the principles developed in the course of Database Technology I gave in the 80's. [NDBS-86]
+:*<b>NDBS</b> (''DBMS languages''). NDBS (Network Database System, 1986-1996) is an educational database management environment allowing Turbo-Pascal programs to manage and use complex data in an efficient, though very intuitive, way. NDBS comprised a runtime library (database handler), a DDL compiler, a 4GL Query Language, a data dictionary, a report generator, a SQL/NDBS converter, an import/export tool (the language of which has been adopted as the external format for DB-MAIN metadata [the *.lun format]), etc. The last version (under the name Pyramid) was developed by D. Rossi, then Master student in the University of Namur. Two original aspects: (1) the data model was a variant of the ER model, (2) the physical engine was a fairly strict implementation of the principles developed in the course of Database Technology I gave in the 80's. [NDBS-86]
 :*<b>Temporal language T-SQL</b> (''DBMS language''). One of the result of project TimeStamp is a variant of SQL extended with bi-temporal dimensions. This variant was named T-SQL (a subset of TSQL2). [P01-02]

@@ Ligne 37 : / Ligne 37 : @@
 :*<b>Languages for CASE tools</b>. [DB-MAIN] [P99-03] [P99-06] [PHD00]
-:*<b>Co-transformation</b> (''language processing''). [P04-03][P06-04] [P06-06]
+:*<b>Co-transformation</b> (''language processing''). Current studies on software intensive system evolution emphasize the concept of co-transformation. When two artefacts A and B interact (e.g., program B working on database A), modifying A may imply modifying B accordingly. If changes to A can be modeled by transformations, the adaptation of B can, under specific conditions, be carried out automatically. The coordinated modification of A and B is called ''co-transformation''.  The idea was first suggested in [B86] to automatically transform ADL algorithms defined on a conceptual schema into algorithms compliant with a logical model such as SQL, standard file structure or CODASYL. More recently, co-transformations were studied in the context of data intensive system evolution. The problem addressed is the following. We consider, as a case study, a legacy database that is to migrate to a modern platform. The best approach consists in reverse engineering the legacy database in order to get its conceptual schema, then to generate a new database according to the new data model. Then the legacy data are transformed and moved to the new database and, finally, the application programs are adapted to the new schema and the new API. The whole process can be described as a co-transformation of schema, data and programs, driven by schema transformation. In this process, program transformation is particularly challenging. The problem is described in [P04-03], [P06-04] and [P06-06], an application in [P08-05] and the full solution, including the use of ASF/SDF for program transformation, in [PHD09].
 :*<b>Program understanding</b> (''language processing''). Database reverse engineering requires the elicitation of implicit (i.e., not explicitly declared in the DDL code) data structures and constraints. This process relies on various techniques such as data analysis, schema analysis and program source code analysis.  Code analysis is a complex matter but it provides essential information on the data structures. For instance, implicit foreign keys can be detected through the examination of the data validation sections that precede the insert statements in application programs. Identification of programming ''clichés'', dependency graph and program slicing are some techniques that have been studied and implemented in DB-MAIN [P96-01] [P98-01] [P98-02] [PHD03]. Recently, we applied dynamic program analysis techniques to the detection of dynamic SQL statements, which are increasingly used in web applications (through JDBC for instance). [P08-02] [PHD09]

@@ Ligne 15 : / Ligne 15 : @@
 :*<b>SPHINX DDL and DML</b> (''DBMS languages''). One of results of the project Large Administrative Databases (1971-1977) was a DBMS based on a Entity-relationship model. It included a data definition language and a data manipulation language for COBOL programs [P78-01] [P78-03]. A detailed specification of these languages can be found in the final report of the project ([R78-01] to [R79-05]).
 :*<b>NUL</b> (''DBMS language''). The Navigational User Language (NUL) was designed to allow end-users to query databases through an Entity-relationship view of data. A query was incrementally built by defining simple objects derived from the conceptual schema and from already defined objects. An interactive interpreter was developed on top of the SPHINX DBMS.  NUL is described in paper [P76-01] and in system manuals [R78-01] to [R78-05].
 :*<b>IDML</b> (''DBMS languages''). Based on the experience of system SPHINX, we experimented wrapper technology to interface application programs with CODASYL databases through a high-level neutral data manipulation language based on a binary data model (1978-1981). This language will be reused later under the name ADL. A prototype wrapper generator was developed [P78-02] [P81-01].
 :*<b>NDBS</b> (''DBMS languages''). NDBS (Network Database System, 1986-1996) is an educational database management environment allowing Turbo-Pascal programs to manage and use complex data in an efficient, though very intuitive, way. NDBS comprised a runtime library (database handler), a DDL compiler, a 4GL Query Language, a data dictionary, a report generator, a SQL/NDBS converter, an import/export tool, etc. The last version (under the name Pyramid) was developed by D. Rossi, then Master student in the University of Namur. Two original aspects: (1) the data model was a variant of the ER model, (2) the physical engine was a fairly strict implementation of the principles developed in the course of Database Technology I gave in the 80's. [NDBS-86]
 :*<b>Temporal language T-SQL</b> (''DBMS language''). One of the result of project TimeStamp is a variant of SQL extended with bi-temporal dimensions. This variant was named T-SQL (a subset of TSQL2). [P01-02]
 :*<b>Scripting Language for SQL</b> (''DBMS language''). MS Access provides two ways to execute SQL statements: as Access queries (simple but single queries only) and embedded in VB programs (powerful but complex). We have designed a scripting language (SQL-Script) through which one can write simple SQL programs. A SQL-Script program is made up of a sequence of SQL statements, but also of variables, macros, loops, alternatives and interaction with users. An interpreter for SQL-Script has been developed in MS Access. [SQL-Script]
 :*<b>Wrappers</b> (''API''). A wrapper is a software component attached to a data source (such as a file and a database) and that provides its users (typically application programs) with a data model that is different from that of the data source. Practically, a wrapper is notably defined by its API. The wrapper technology and architecture have been extensively studied, experimented and used since 1981 in various contexts.
 ::#Database access code generation [B86].
 ::#Legacy database interoperability [P99-01] [P01-03] [P04-08] [P05-03]  [P06-08].
 ::#Information system evolution and migration [P03-03] [P04-04] [P06-04] [P08-05] [PHD09].
 ::#High-level database programming through conceptual object classes to support fast system evolution [P10-05].
 :*<b>Temporal API T-ODBC</b> (''API''). The T-SQL language interacts with the database through the temporal API T-ODBC which is an extension of ODBC [P01-02]. The temporal database is an active DB implemented in Oracle 9.
 :*<b>Conceptual API for system evolution</b> (''API''). The fast evolution of applications systems forces developers to adopt defensive programing techniques to facilitate system adaptation. We have developed a Java API that offers data manipulation at the conceptual level (according to a variant of the Entity-relationship model). The API is automatically generated by the DB-MAIN CASE tool according to rules that minimize the impact of changes on the database, on the data and on the application programs [P10-05].
@@ Ligne 33 : / Ligne 38 : @@
 :*<b>Co-transformation</b> (''language processing''). [P04-03][P06-04] [P06-06]
 :*<b>Program understanding</b> (''language processing''). Database reverse engineering requires the elicitation of implicit (i.e., not explicitly declared in the DDL code) data structures and constraints. This process relies on various techniques such as data analysis, schema analysis and program source code analysis.  Code analysis is a complex matter but it provides essential information on the data structures. For instance, implicit foreign keys can be detected through the examination of the data validation sections that precede the insert statements in application programs. Identification of programming clichés, dependency graph and program slicing are some techniques that have been studied and implemented in DB-MAIN [P96-01] [P98-01] [P98-02] [PHD03]. Recently, we applied dynamic program analysis techniques to the detection of dynamic SQL statements, which are increasingly used in web applications (through JDBC for instance). [P08-02] [PHD09]
 *'''Keywords'''

@@ Ligne 50 : / Ligne 50 : @@
 :'''[P04-04]''' Jean Henrard, Anthony Cleve and Jean-Luc Hainaut. <u>Inverse Wrappers for Legacy Information Systems Migration</u>, in ''Proceedings of 1st International Workshop on Wrapper Techniques for Legacy Systems'', (WCRE’04/WRAP’04), Computer Science Report, Volume 04-34, pages 30-43, Technische Universiteit Eindhoven, 2004. [http://www.fundp.ac.be/recherche/publications/page_view/50552/ [description]] [http://www.info.fundp.ac.be/~dbm/Documents/Publications-LIBD/Articles-Conferences/conferences-WCRE/WCRE-2004-Wrap/WCRE-Wrapper-2004.pdf [full text]]
 :'''[P04-03]''' Anthony Cleve, Jean Henrard and Jean-Luc Hainaut. <u>Co-transformations in Information System Reengineering</u>, in ''Proceedings of the 2nd International Workshop on Metamodels, Schemas, and Grammars for Reverse Engineering'', (WCRE’04/ATEM-04), Electronic Notes in Theoretical Computer Science, Volume 137, pages 5-15, Elsevier, 2005. [http://www.fundp.ac.be/recherche/publications/page_view/50551/ [description]] [http://www.info.fundp.ac.be/~dbm/Documents/Publications-LIBD/Articles-Conferences/conferences-WCRE/WCRE-2004-META/WCRE-ATEM-2004.pdf [full text]]
 :'''[P03-03]''' Jean-Marc Hick and Jean-Luc Hainaut. <u>Strategy for database application evolution: the DB-MAIN approach</u>, in ''Proceedings of the 22nd International Conference on Conceptual Modeling'', (ER’03), Lecture Notes in Computer Science, Volume 2813, pages 291-306, Springer-Verlag, 2003. [http://www.fundp.ac.be/recherche/publications/page_view/46018/ [description]] [http://www.info.fundp.ac.be/~dbm/Documents/Publications-LIBD/Articles-Conferences/conferences-ER/ER-2003/ER-2003.pdf [full text]]
 :'''[P01-03]''' Philippe Thiran and Jean-Luc Hainaut. <u>Wrapper Development for Legacy Data Reuse</u>, in ''Proceedings of the 8th Working Conference on Reverse Engineering'', (WCRE’01), pages 198-207, IEEE Computer Society, 2001. [http://www.fundp.ac.be/recherche/publications/page_view/37655/ [description]] [http://www.info.fundp.ac.be/~dbm/Documents/Publications-LIBD/Articles-Conferences/conferences-WCRE/WCRE-2001/WCRE-2001.pdf [full text]]