No full-text available
To read the full-text of this research,
you can request a copy directly from the authors.
EB3 Attribute Definitions: Formal Language and Application
Abstract
eb 3 is a trace-based formal language created for the specification of information systems (IS). In this technical report, we present the eb 3 formal language for attribute definitions. Attributes, linked to entities and associations of an IS, are computed in eb 3 by recursive functions on the valid traces of the system. The syntax and the main properties of the language are introduced. Then, we aim at synthesizing imperative programs that correspond to eb 3 attribute definitions. Thus, each eb 3 action is translated into a transaction. eb 3 attribute definitions are analysed to determine the tables and the key values affected by each action. Some key values are determined from SELECT statements that correspond to first-order predicates in eb 3 attribute definitions. To avoid inconsistencies because of the sequencing of SQL statements in the transactions, temporary variables and/or tables are introduced for these key values. We show the main patterns for the SELECT statements used in the temporary variables and/or tables. The SQL statements are then ordered by table. Generation of
... Finally, book entity bId is consumed by action Discard. The complete process expressions for the example are given in [15]. ...
... In this paper, we just provide an informal description of these functions. The syntax and semantics are detailed in [15]. ...
... The different steps of the algorithm, which are summed up in this section, are detailed in [15], [16], [14]. ...
This article presents the main features of the APIS project that addresses the rapid development of information systems from formal specifications. Information systems are specified using EB3, a trace-based formal language. The se- quences of input events accepted by the system are described with a process algebra; they represent the valid traces of the information system. Entity types, associations and attributes are described using a class diagram and computed by means of recursive functions defined on the valid traces of the system. In the APIS framework, three tools have been developed. A first tool, called DCI-WEB, allows the generation of Web interfaces from GUI specifications. To query and/or to update the system, an end-user can trigger an event through the Web interface. This event is then analyzed by EB3 PAI, an interpreter for EB 3 process expressions. Finally, the tool EB3 TG generates, for each EB3 action, a Java program that executes a relational database transaction. The synthesized transactions implement the specification of the information system's data structure and are used by the interpreter to update or query the database. The article also brings out the main future developments of the
... Finally, book entity bId is consumed by action Discard. The complete process expressions for the example are given in [14]. ...
... For each input clause, we should have var(u i ) ⊆ var( − → p i ). The syntax of key definitions is provided by [14]. ...
... . Any reference to a key eKey or to an attribute b j (j can be equal to i) in an input clause is always of the form eKey(f ront(s)) or b j (f ront(s), ...). The syntax of non-key attribute definitions can be found in [14]. ...
EB<sup>3</sup> is a trace-based formal language created for the specification of information systems (IS). Attributes, linked to entities and associations of an IS, are computed in EB<sup>3</sup> by recursive functions on the valid traces of the system. We aim at synthesizing relational database transactions that correspond to EB<sup>3</sup> attribute definitions. Each EB<sup>3</sup> action is translated into a transaction. EB<sup>3</sup> attribute definitions are analysed to determine the key values affected by each action. Some key values are retrieved from SELECT statements that correspond to first-order predicates in EB<sup>3</sup> attribute definitions. To avoid problems with the sequencing of SQL statements in the transactions, temporary variables and/or tables are introduced for these key values. Generation of DELETE statements is straightforward, but distinguishing updates from insertions of tuples requires more analysis
... For each input clause, we have var(u i ) ⊆ var( − → p i ). The syntax of key definitions is given in [19]. ...
... . Any reference to a key eKey or to an attribute b j (j can be equal to i) in an input clause is always of the form eKey(f ront(s)) or b j (f ront(s), ...). The syntax of non-key attributes is provided by [19]. For example, the definitions of attributes title and nbLoans are the following ones. ...
eb
3 is a trace-based formal language created for the specification of information systems (IS). Attributes, linked to entities and associations of an IS, are computed in eb
3 by recursive functions on the valid traces of the system. On the other hand, B is a state-based formal language also well adapted for the specification of IS. In this paper, we deal with the synthesis of B specifications that correspond to eb
3 attribute definitions, in order to specify and verify safety properties like data integrity constraints. Each action in the eb
3 specification is translated into a B operation. The substitutions are obtained by an analysis of the CAML-like patterns used in the recursive functions that define the attributes in eb
3. Our technique is illustrated by an example of a simple library management system.
... EB 3 expressions are close to the user view and complex constraints inside and between entities are easy to specify in EB 3 [4]. The input-output rules of the example are described in [7]. ...
... Tables. The analysis of the input clauses is summed up in this paper; the algorithms are presented in [7]. When a pattern matching condition evaluates to true, an assignment of a value for each free variable in the input clause has been determined. ...
EB3 is a trace-based formal language created for the specification of information systems (IS). Attributes, linked to entities and associations of an IS, are computed in EB3 by recursive functions on the valid traces of the system. In this paper, we show how to synthesize relational database transactions that cor- respond to EB3 attribute definitions. Thus, each EB3 action is translated into a transaction. EB3 attribute definitions are analysed to determine the key values af- fected by each action. To avoid problems with the sequencing of SQL statements in the transactions, temporary variables and/or tables are introduced for these key values.
... The different steps of the algorithm are only summed up in this paper; they are detailed in Gervais et al., 2005b;Gervais et al., 2005a). ...
... Moreover, they allow us to define transactions independently of the statements ordering. We have identified the most typical patterns of predicates and their corresponding SELECT statements in (Gervais et al., 2005b). The key values to delete are in expressions expr of the form eKey(front (s)) − {k } in the input clauses of key definitions. ...
EB3 is a formal language for specifying information systems (IS). In EB3, the sequences of events accepted by the system are described with a process algebra; they represent the valid traces of the IS. Entity type and association attributes are computed by means of recursive functions defined on the valid traces of the system. In this paper, we present EB3TG, a tool that synthesizes Java programs that execute relational database transactions which correspond to EB3 attribute definitions.
... Dans [GFLB05], des patrons supplémentaires ontété définis pour les prédicats de base qui impliquent des ensembles. En effet, un ensemble de valeurs peut parfoisêtre retourné par une définition d'attribut. ...
Thèse réalisée en cotutelle entre le CNAM et l'Université de Sherbrooke (Québec)
... 8 must have exactly 2 parameters eb 3 tg génère ensuite les programmes Java qui exécutent des transactions de BD relationnelle qui correspondent aux définitions d'attributs, en fonction du schéma de BD généré. Les règles de synthèse des transactions sont détaillées dans [GFLB05]. Par exemple, la méthode Java générée pour l'action Lend est présentée dans la figure 7. On y retrouve la structure typique d'une transaction : une série d'opérations est suivie d'un commit(), et en cas d'erreur, un rollback() est exécuté. ...
eb
3 is a trace-based formal language created for the specification of information systems. In eb
3, each entity and association attribute is independently defined by a recursive function on the valid traces of external events.
This paper describes an algorithm that generates, for each external event, a transaction that updates the value of affected
attributes in their relational database representation. The benefits are twofold: eb
3 attribute specifications are automatically translated into executable programs, eliminating system design and implementation
steps; the construction of information systems is streamlined, because eb
3 specifications are simpler and shorter to write than corresponding traditional specifications, design and implementations.
In particular, the paper shows that simple eb
3 constructs can replace complex SQL queries which are typically difficult to write.
En systèmes d'information, le concepteur a plutôt tendance à utiliser des méthodes dites semi-formelles (OMT, UML,...) basées principalement sur des notations graphiques (diagramme de classes, diagramme d'états/transitions,...) qui permettent une représentation intuitive et synthétique du système à modéliser. Néanmoins ces méthodes souffrent encore d'un manque de sémantique précise pour leurs différents concepts. Les méthodes formelles(B, VDM, Z,...), basées sur des notations mathématiques(fonctions, relations,...), permettent quant à elle l'obtention d'une spécification non seulement précise et concise mais surtout analysable par des outils. Un ensemble de concepts communs aux différentes méthodes semi-formelles a été défini ainsi que des règles permettant la formalisation en B de ces derniers[NGUY98]. Dans un premier temps, l'objectif de notre travail a été la conception d'un outil formel qui implémente les règles de traduction définies, permettant ainsi la traduction automatique des différents concepts graphiques en des spécifications B[FACO99]. En effet, l'utilisation des méthodes formelles en conception de systèmes d'information doit être supportée par des outils qui allègent le travail du concepteur et réduisent ainsi le coût de développement. Pour chacun des aspects (statique et dynamique) d'une application, nous avons extrait une spécialisation du métamodèle [FACO99] UML qui satisfait les besoins de notre niveau d'abstraction (niveau conceptuel). Dans cet outil, réalisé en Caml, sont définis une syntaxe abstraite UML, traduction interne du métamodéle spécialisé, et un ensemble de fonctions Caml qui permet de traduire une application UML en des spécifications B. Les différents diagrammes UML sont saisis à l'aide de l'atelier Rose, sont récupérés sous forme de fichiers texte et traduits en syntaxe abstraite UML. Après différentes vérifications de cohérence des diagrammes (les opérations spécifiées dans les diagrammes E/T sont des opérations de la classe concernée,...), des spécifications B sont générées. Actuellement, nous travaillons sur la génération automatique, en utilisant le processus de raffinement B, d'une implémentation relationnelle à partir des spécifications B ainsi obtenues. De manière générale, le processus de raffinement demeure une tâche manuelle, relativement lourde, en particulier en phase de preuve. Notre but est de concevoir un assistant de preuve automatique, dédié au domaine des applications bases de données, qui réduirait le plus possible le coût élevé de cette phase. Pour cela un ensemble de règles génériques de raffinement B a été proposé[LALE00]. Les règles prennent en compte le diagramme de classes(données et opérations de base) et permettent la définition de la structure de données relationnelles et du code des différentes opérations SQL (insertion et suppression). En utilisant le prouveurB, ces règles ont été prouvées donnant lieu ainsi à des scénarios de preuves génériques et donc réutilisables par instanciation. L'implémentation ainsi obtenue est prouvée formellement correcte par rapport à la spécification initiale. La suite prévue pour cette thèse concerne: • l'extension du processus de raffinement afin de prendre en compte des transactions plus complexes, • l'extension de l'outil: -implémentation des différentes règles de raffinement permettant la traduction automatique des spécifications abstraites ainsi obtenues en une implémentation SQL, -automatisation du processus de preuve.
This paper describes a formal method for specifying the observable (external) behavior of information systems using a process algebra and input-output traces. Its notation is mainly based on the entity concept, borrowed from the Jackson System Development method, and integrated with the requirements class diagram to represent data structures and associations. The specification process promotes modular and incremental description of the behavior of each entity through process abstraction, entity type patterns, and entity attribute function patterns. Valid system input traces result from the composition of entity traces by using parallel composition operations. The association between input traces and outputs through an input-output relation completes the specification process.
We present a proposed query language for extended entity relationship schemas. The language improves on previous proposals by using only concepts explicitly in a given schema. It includes quantiers and aggregates to allow complex queries to be expressed, and it allows derived subtypes, attributes and relation- ships to be dened and used in queries. Further extensions are discussed.
A mathematical model for communicating sequential processes is
given, and a number of its interesting and useful properties are
stated and proved. The possibilities of nondetermimsm are fully
taken into account.
This paper compares two formal methods, B and eb
3, for specifying information systems. These two methods are chosen as examples of the state-based paradigm and the event-based paradigm, respectively. The paper considers four viewpoints: functional behavior expression, validation, verification, and evolution. Issues in expressing event ordering constraints, data integrity constraints, and modularity are thereby considered. A simple case study is used to illustrate the comparison, namely, a library management system. Two equivalent specifications are presented using each method. The paper concludes that B and eb
3 are complementary. The former is better at expressing complex ordering and static data integrity constraints, whereas the latter provides a simpler, modular, explicit representation of dynamic constraints that are closer to the user’s point of view, while providing loosely coupled definitions of data attributes. The generality of these results from the state-based paradigm and the event-based paradigm perspective are discussed.
Specification languages such as LOTOS and SDL play an important
role in the design and implementation of distributed systems. Their
formal syntax and semantics supports the development of compilers and of
verification tools. This paper introduces a generic and uniform approach
to support such languages in verification tools. We present a compiler
generator which, given the description of a specification language,
automatically generates a corresponding implementation. More
specifically, the syntax and semantics of the specification language has
to be defined using J. Meseguer's (1992, 1996) rewriting logic
formalism, which is a unified semantic framework for concurrency. From
this description, a compiler is derived which parses a given system
specification and computes the corresponding semantic object, such as a
labelled transition system. The latter can be processed further in
subsequent analysis and verification phases. Thus, we propose some kind
of “meta-prototyping” approach, in the sense that new
specification formalisms for distributed systems can easily be tested
without the need to develop an implementation by hand
This paper presents the high-level query language SQL/EER for an extended Entity-Relationship model (EER model). SQL/EER directly supports all the concepts of the EER model and takes into account well-known features that are integral part of contemporary query languages, e.g. arithmetic and aggregate functions.In contrast to usual descriptions of query languages, we give SQL/EER a complete formal specification of syntax and semantics. The syntax is defined by using an attribute grammar which fixes the context-free structure and the context-sensitive rules. The operational semantics is defined by formally translating SQL/EER queries into queries of an existing, semantically well-defined calculus. The attribute grammar is extended to cover this translation, too.The query language SQL/EER is used in a database design environment. In this context, the formal specification of its syntax and the semantics has been used to implement a syntax-directed editor and a query interpreter for SQL/EER.
A programming course should concentrate as much as possible on a program's logical structure and design rather than simply show how to write code. The Functional Approach to Programming achieves this aim because logical concepts are evident and programs are transparent so can be written quickly and cleanly. In this book the authors emphasise the notions of function and function application which relate programming to familiar concepts from mathematics and logic. They introduce functional programming via examples but also explain what programs compute and how to reason about them. They show how the ideas can be implemented in the Caml language, a dialect of the ML family, and give examples of how complex programs from a variety of areas (such as arithmetic, tree algorithms, graph algorithms, text parsing and geometry) can be developed in close agreement with their specifications. Many exercises and examples are included throughout the book; solutions are also available.
Most computers are used in an organisational setting and most organisational information systems are database systems. A database system is one in which the simple statements far outnumber the complex ones, to the extent that a special database management system is required to enable sufficiently rapid access to the data thus stored. SQL is the standard language for database access and manipulation. Z is a formal notation which has achieved some degree of acceptance - even popularity. Yet, Z and SQL are rarely considered in conjunction, which is unfortunate because both languages have their roots in set theory and predicate calculus. This paper examines some of the issues involved in mapping from a Z specification to an SQL-based implementation.
EB3PAI: An interpreter for the eb 3 specification language
- B Fraikin
- M Frappier
B. Fraikin and M. Frappier. EB3PAI: An interpreter for the eb 3 specification language. In 15th International Conference on Software and
Systems Engineering and their Applications (ICSSEA), December 2002.
APIS -Automatic Production of Information Systems
- M Frappier
- B Fraikin
- R Laleau
- M Richard
M. Frappier, B. Fraikin, R. Laleau, and M. Richard. APIS -Automatic Production of Information Systems. In AAAI Spring Symposium,
pages 17-24, Stanford, USA, March 2002. AAAI Press.
Description comportementale d'interface web
- J.-G Terrillon
J.-G. Terrillon. Description comportementale d'interface web. Master's
thesis, Département d'informatique, Université de Sherbrooke, 2005.