Main index

Help Index for DB-MAIN Version 8

General Presentation

Objects

In a project

Project

Meta-object

Meta-property

Product

Primitive process

Engineering process

Decision

Connection

Text

Product set

Schema

In a data schema (Entity-Relationship Schema or UML Class Diagram)

Collection

Entity type

Rel-type

Role

Attribute

Group

Constraint

Processing unit

Note

In a processing schema (UML Activity Diagram or UML Use Case Diagram)

Processing unit

Internal or external object

Object state

Actor

Relation

Note

Transformations

Definitions

Elementary Transformations

Assistants

Global Transformation

Advanced Global Transformation

Schema Analysis

Integration

Text Analysis

Referential Key finding

Menus

File

Edit

Product

New

Transform

Assist

Engineering/History

Log

View

Window

Help

Shortcuts

Standard tool palette

Graphical tool palette

UML role position tool palette

Transformations tool palette

Reverse engineering tool palette

User tool palettes

Process modeling tool palette

Windows

Textual data schema window (ER and UML Class Diagram)

Graphical data schema window (ER and UML Class Diagram)

Textual UML activity diagram window

Graphical UML activity diagram window

Textual UML use case diagram window

Graphical UML use case diagram window

Graphical project window

Source file window

Method window


General presentation

General presentation of DB-MAIN

Warning

The DB-MAIN CASE tool Education version is limited to 500-object projects. The Demo version is limited to 250-object projects. When dealing with larger projects, the input/output functions (save, import, generate, Voyager programs, etc) are disabled.

How to get the last version

The last version of the CASE tool and Viewer are available on the DB-MAIN web site (www.db-main.be), on the REVER s.a. web site (www.rever-sa.com) or on the Laboratory of Database Application Engineering (LIBD) web site (www.info.fundp.ac.be/libd). At the latter address, you will also find other resources related to database engineering, such as tutorials, manuals, case studies, slides, exercises, programs,….

The DB-MAIN CASE tool

DB-MAIN is a general purpose software environment dedicated to Database application engineering. It can be used either as a supporting toolset for system engineering, or as a CASE tool development environment (i.e., a CASE tool factory or Meta-CASE).

In its current version, Version 7.1 (October 2004), DB-MAIN offers a strong support for most forward and reverse engineering activities. More specifically, it includes the following functions and components:

  • specifications management: access, browsing, creation, update, copy, analysis, memorizing;

  • a project history representation including all products (data and processing schemas, source texts, generated programs), processes that use or generate products and decisions;

  • a generic, wide-spectrum representation model for conceptual, logical and physical objects;

  • a graphical representation of ERA Schemas, UML Class, Activity and Use Case Diagrams;

  • a generic model that describes procedural components of information systems at various abstraction levels as well as their relations;

  • semantic and technical semi-formal annotations attached to each specification object;

  • multiple views of specifications (4 hypertext and 3 graphical views), some of which are particularly suitable for very large schemas;

  • a toolbox of more than 25 semantics-preserving transformational operators intended to carry out in a systematic way such activities as conceptual normalization, development of optimized logical and physical schemas from conceptual ones, and conversely (i.e. reverse engineering);

  • code generators (including a sophisticated SQL generator, XML DTD and XML Schema generators) and report generators;

  • code parsers extracting physical schemas from SQL, COBOL, CODASYL, IMS, XML DTD and RPG source programs;

  • interactive and programmable source text analyzers that can be used, a.o., to detect complex programming patterns or clichés in source texts, and to build data flow diagrams through program variables;

  • a sophisticated name processor that allows to clean, normalize, convert and translate the names of selected objects in a schema;

  • a method engine that helps users to follow engineering methods, maintains the history of engineering activities and makes it possible to replay them automatically or in an assisted way;

  • import and export of specifications;

  • a set of assistants. An assistant is a kind of expert in a specific kind of tasks, or in a class of problems. It is intended to help the analyst to carry out frequent, tedious or complex tasks. It also allows to develop scripts in order to automate process fragments. A library of predefined scripts automating the most frequent activities is provided. Six assistants are currently available:

    - | a basic global transformation assistant proposes some standard solutions to handle the most frequent structural problems;
- | an advanced global transformation assistant automates the application of complex transformations and makes it possible to develop sophisticated scripts;
- | a schema analysis assistant allows to evaluate schemas against user defined or predefined data submodels and to search large schemas for complex structural patterns;
- | an integration assistant offers a set of tools for integrating schemas, entity types, rel-types and compound attributes at various levels of automation;
- | a reverse engineering assistant offers a set of tools dedicated to text analysis and program extraction;
- | a referential key assistant uses some popular heuristics to find foreign keys in legacy databases.
DB-Main also includes meta level functions dedicated to the development of specialized CASE tools and functions. There are three kinds of customization:
     | Methodological customization
Thanks to its basic architectural assumptions (e.g. generic specification model, transformation operators, toolkit architecture), the tool is methodologically neutral and can assist the analyst in following a large spectrum of methodologies. Methodological customization is carried out in two steps. First, the analyst describes his methodology with the Method Specification Language. Second, he applies it with the help of the DB-MAIN method engine. The language provides components for the description of methodology processes, strategies and products, as well as specific aspects of the user interface (e.g., menu contents, graphical conventions, concept names). This customization is useful for user guidance. It also provides a precise and structured way to record process history, thus enabling to control system maintenance and evolution.
 | Functional extension
The Voyager 2 language allows the CASE engineer (analyst or method engineer) to develop new functions that can be seamlessly incorporated into the tool. For instance, it allows to build specific report and code generators, text analyzers (e.g. importers), complex transformations or specifications checkers for specific problems and usage contexts.
Voyager 2 is a complete, 4th-generation, semi-procedural language. It offers predicative access to the repository, analysis and generation of external texts, definition of recursive functions and procedures, and a sophisticated list manager. It allows to develop swiftly complex functions. Several DB-MAIN components were developed in Voyager 2.
 | Extension of the repository
The repository is implemented as an object base in which DB-MAIN records the current methodology, the project history, and the products specifications (mainly schemas and texts). New properties can be dynamically added and managed through Voyager 2 procedures.

    The DB-MAIN Viewer

    The DB-MAIN Viewer is a simple viewer for DB-MAIN projects. It can be distributed and used freely in order to view and print DB-MAIN projects, as well as to generate reports.

    In its current version, Version 7.1 (October 2004), this tool includes the following functions and components:

  • Loader for any DB-MAIN project;

  • History viewer and browser;

  • Schema and text viewer;

  • Selection, marking, moving, coloring of schema and history elements;

  • Generation of RTF or customized reports (note that customized report generators can only be written with a full version of DB-MAIN).

    Contact

    REVER s.a.

    Bd Tirou 130

    B-6000 Charleroi

    Belgium

    Phone: +32-71-20 71 61

    Fax: +32-71-20 71 65

    e-mail: info@rever-sa.com


Project

A project is a structured set of products, primitive processes, engineering processes and decisions.

The project properties dialog box (menu File/Project properties ...)

A project has the following features:

Name

:

to give a name to the project (mandatory, 100 characters);

Short name

:

to give a short name to the project (optional, 12 characters);

Methodology

:

to choose a *.LUM file containing a method to be followed during the project (optional, pathname);

Creation date

:

automatically generated when the project is created;

File name

:

the name of the file where the project is saved (automatically updated);

Sem

:

to give a semantic description to the project;

Tech

:

to give a technical description to the project;

Prop

:

to give value(s) to the meta-properties of the project.

Exit buttons

Ok

:

to close the dialog box saving changes;

Cancel

:

to close the dialog box discarding changes.


Meta-object

A meta-object is the representation of a project element in a project. Users cannot create, examine or modify meta-objects. The existing meta-objects are project, schema, text, product-set, entity type, rel-type, atomic and compound attributes, processing unit, role, group, collection, control flow, object flow, association, actor, actor generalization, object state. These meta-objects are the objects of the DB-MAIN repository and they exist in all projects.


Meta-property

A meta-property is a dynamic property attached to a meta-object. The user can add properties to meta-objects. The functions of meta-properties are: system (meta-property existing in all projects; its values cannot be updated), updatable (its values can be updated), multivalued (it can have several values) and predefined values (its values are predefined).

The values of meta-properties must be specified in the Meta-properties dialog box (see below) of the corresponding meta-object.

The Meta-property management dialog box (menu Product/Meta-properties )

After selecting a meta-object in the left list, its meta-properties appear in the right list. The following buttons are displayed:

Create | : | to create a new meta-property for the selected meta-object (i.e. to open the Meta-property definition dialog box, see below);
Examine | : | to examine the selected meta-property (i.e. to open the Meta-property definition dialog box, see below);
Modify | : | to modify the selected meta-property (i.e to open the Meta-property definition dialog box, see below). System meta-properties cannot be modified;
Remove | : | to remove the selected meta-property (system meta-properties cannot be removed);
Close | : | to close the dialog box.

The Meta-property definition dialog box (Create, Modify or Examine button in the Meta-property management dialog box)

A meta-property has the following features:

Name | : | to give a name to the meta-property (mandatory, 100 characters);
Type | : | to set the type of the meta-property (boolean, char, integer, real, string; default is string);
Updatable | : | if updatable is checked, the values of this meta-property can be modified;
Multivalued | : | if multivalued is checked, this meta-property can have several values;

Predefined values:

if predefined values is checked, the values of this meta-property are predefined. These values are shown in the editable list at the bottom of the property box. This list is saved in the semantic description of the meta-property with the following syntax:

#Values=

value1

value2

...

valueN

#

The predefined values are listed between the words #Values= and #. Each value takes one single line.

Sem

:

to give a semantic description to the meta-property.

Exit buttons

Ok

:

to close the dialog box saving changes;

Cancel

:

to close the dialog box discarding changes.

A meta-property is identified by its name within a meta-object.

See also:

Predefined meta-properties.

The Meta-properties dialog box (Prop button in the dialog box of schema objects)

After selecting a meta-property in the left list, its value for the selected object appears in the right list. If this meta-property is updatable and not system, its value can be modified. The following buttons are displayed:

Clear | : | to re-initialize the value of the selected meta-property (nothing for char and string, 0 for integer and real, false for Boolean, nothing in the left list if the values are predefined);
Ok | : | to close the dialog box saving changes;
Cancel | : | to close the dialog box discarding changes.


Predefined meta-property

Predefined meta-properties

Some repository objects have predefined meta-properties. They are detailed below:

Default value | : | The default value of an atomic attribute or user-defined domain is assigned when no value is explicitly given at creation time.
Value constraint | : | A value constraint can be associated with any atomic attribute or user-defined domain. It is made up of a list of constants and/or ranges. The attribute value must belong to this list.
Stereotype | : | A stereotype is a named subcategory that has specific characteristics or behaviour. This meta-property is available for attributes, collections, entity types, rel-types, roles, processing units, control flows, object flows, actors, actor generalizations, associations, object states.
Line | : | Contains the line number of the file from which the object was extracted (COBOL, SQL or IDS files) or to which it was generated (SQL files).
 |  | This predefined meta-property is also used by the program slicing module to store the line number of a program file where a processing unit has been defined. This meta-property is available for attributes, collections, entity types, groups, processing units and schemas.
Phys_len | : | Contains the physical length of an atomic attribute extracted from a COBOL or IDS file.
Rec_id | : | Contains the record number of an entity types extracted from an IDMS DDL file (a CODASYL dialect).
List_view | : | Contains the names of the views defined on a schema (multivalued).
Isview | : | Tells whether a schema is a view or not (boolean).
View | : | Contains the names of the views in which an object appears (multivalued). This meta-property is available for attributes, collections, entity types, rel-types and processing units.
User-constraint | : | Contains the name of the user-defined constraint associated with a group (only for groups).
All predefined meta-properties are managed by DB-MAIN except for the default value, value constraint and stereotype properties that are managed by the user through the Meta-properties dialog box.


Product

A product is either a schema, a text or a product set.


Schema

A schema is a view of data or processing structures of an existing or future database. It is expressed in an extended entity-relationship formalism. This view can be conceptual, logical, physical, complete or partial.

The Schema properties dialog box (menu Product/Properties ...)

A schema has the following features:

Name

:

to give a name to the schema (mandatory, 100 characters);

Short name

:

to give a short name to the schema (optional, 12 characters);

Version

:

to indicate the schema version (optional, 16 characters);

Schema type

:

automatically set if a method is followed during the project;

Creation date

:

automatically generated when the schema is created;

Last update

:

automatically generated when the schema is updated;

Entity/Relationship schema:

if checked at creation time, the schema is a ER Schema that can include collections, entity types, relationship types, attributes, groups, constraints, sub-types and processing units (inaccessible after schema creation);

UML class diagram:

if checked at creation time, the schema is a UML Class Diagram that can include collections, entity types, relationship types, attributes, groups, constraints, sub-types and processing units (inaccessible after schema creation);

UML activity diagram:

if checked at creation time, the schema is a UML Activity Diagram that can include activities, synchronization states, signal sendings, signal receipts, decisions, internal or external objects or relationships (entity types, relationship types, attributes or collections coming from data schemas) (inaccessible after schema creation);

UML use cases diagram:

if checked at creation time, the schema is a UML Use Case Diagram that can include use cases, actors, extension, inclusion or generalization relationships between use cases and generalization relationships between actors (inaccessible after schema creation);

Sem

:

to give a semantic description to the schema;

Tech

:

to give a technical description to the schema;

Prop

:

to give value(s) to the meta-properties of the schema;

Connection

:

to create connections with the products that depend on the schema.

Exit buttons

Ok

:

to close the dialog box saving changes;

Cancel

:

to close the dialog box discarding changes.

A schema is identified within a project by its name and its version.


Text

A text is the representation of any document (source file, *.txt file, ...) that is not a schema.

The Text properties dialog box (menu Product/Properties ...)

A text has the following features:

Name

:

to give the full file name (path); it can be modified through the Browse button;

Version

:

to indicate the file version (optional, 16 characters);

File type

:

displays the type of the file. If the file type is EXT, then this text cannot be viewed inside the DB-MAIN environment. An external application must be used, depending on the file extension and the Windows system configuration.

Text type

:

automatically set if a method is followed during the project;

Creation date

:

automatically generated when the text is created;

Last update

:

automatically generated when the text properties are modified;

Sem

:

to give a semantic description to the text;

Tech

:

to give a technical description to the text;

Prop

:

to give value(s) to the meta-properties of the text;

Connection

:

to create connections with the products that depend on the text.

Exit buttons

Ok

:

to close the dialog box saving changes;

Cancel

:

to close the dialog box discarding changes.

A text is identified within a project by its name and its version.


Product set

A product set represents a set of schemas or texts. This concept provides a useful way to organize large sets of products.

The Product set dialog box (menu Product/Properties ...)

A product set has the following features:

Name

:

to give a name to the product set (mandatory, 100 characters);

Version

:

to indicate the product set version (optional, 16 characters);

Type

:

automatically updated if a method is followed during the project;

Creation date

:

automatically generated when the product set is created;

Last update

:

automatically generated when the product set is updated;

Set elements

:

displays the list of schemas and texts that belong to the product set;

Hide unused products:

if checked, the set elements (schemas or texts) that are not explicitly used or generated by processes are hidden;

Open set element:

to open the window of the products selected in the set elements list box;

Sem

:

to give a semantic description to the product set;

Tech

:

to give a technical description to the product set;

Prop

:

to give value(s) to the meta-properties of the product set;

Connection

:

to create connections with the products that depend on the product set.

Exit buttons

Ok

:

to close the dialog box saving changes;

Cancel

:

to close the dialog box discarding changes.

A product set is identified within a project by its name and its version.


Connection

A connection is an oriented link between two products.

The Connection properties dialog box (Connection button in the Schema or Text properties dialog box)

A connection has the following features:

Products

:

to choose the products (target of the connection) that depend on the current product;

Exit buttons

Ok

:

to close the dialog box saving changes;

Cancel

:

to close the dialog box discarding changes.


Primitive process

A primitive process is a product transformation performed by means of primitive functions of the CASE tool. All the work done is recorded in the transformed product log file.

The primitive Process properties dialog box (menu Engineering/Properties ...)

A primitive process has the following features:

Name

:

to give a name to the process (mandatory, 100 characters);

Start date

:

automatically generated when the process is started; it is part of the process identifier;

Start time

:

automatically generated when the process is started; it is part of the process identifier;

End date

:

automatically generated when the process is terminated;

End time

:

automatically generated when the process is terminated;

Description

:

to give a description of the process; it can also contain some hypotheses put forward in order to carry out the process.

Exit buttons

Edit I/O

:

to edit input/output/update product lists;

Ok

:

to close the dialog box saving changes;

Cancel

:

to close the dialog box discarding changes.

A primitive process is identified within a project by its name, its start date and its start time.


Engineering process

An engineering process is a phase of a project during which several sub-processes are performed. It is represented by a graph that contains all the sub-processes, as well as the products they use or produce and the decisions made to keep or abandon some products.

The engineering Process properties dialog box (menu Engineering/Properties ...)

An engineering process has the following features:

Name

:

to give a name to the process (mandatory, 100 characters);

Start date

:

automatically generated when the process is started; it is part of the process identifier;

Start time

:

automatically generated when the process is started; it is part of the process identifier;

End date

:

automatically generated when the process is terminated;

End time

:

automatically generated when the process is terminated;

Description

:

to give a description of the process; it can also contain some hypotheses put forward in order to carry out the process.

Exit buttons

Edit I/O

:

to edit input/output/update product lists;

Ok

:

to close the dialog box saving changes;

Cancel

:

to close the dialog box discarding changes.

A engineering process is identified within a project by its name, its start date and its start time.


Decision

A decision is a documentation object used to show that some products are preferred and others are abandoned during a process. It also contains some comments used to justify the choices.

The Decision properties dialog box (menu Engineering/Properties ...)

A decision has the following features:

Name

:

to give a name (mandatory, 100 characters);

Date

:

automatically generated when the decision is made; it is part of the decision identifier;

Time

:

automatically generated when the decision is made; it is part of the decision identifier;

Abandoned

:

to list the products that must be abandoned;

Kept

:

to list the products that must be kept;

Comment

:

to comment on the decision (e.g. to give a rationale).

Exit buttons

Ok

:

to close the dialog box saving changes;

Cancel

:

to close the dialog box discarding changes.

A decision is identified within a project by its name, its start date and its start time.


Collection

A collection is a repository of entity types. In logical and physical schemas, collections can be used to represent files and the like.

The Collection properties dialog box (menu New/Collection ...)

A collection has the following features:

Name

:

to give a name to the collection (mandatory, 100 characters);

Short name

:

to give a short name to the collection (optional, 12 characters);

Entity types

:

to select the entity types that belong to the collection;

Sem

:

to give a semantic description to the collection;

Tech

:

to give a technical description to the collection;

Prop

:

to give value(s) to the meta-properties of the collection (for instance to the predefined stereotype meta-property).

Exit buttons

New coll.

:

to create a new collection, saving changes to the current one;

Ok

:

to close the dialog box saving changes;

Cancel

:

to close the dialog box discarding changes.

A collection is identified within a schema by its name.


Entity type

An entity type materializes a class of entities that represent objects. These objects can be real world abstract or concrete entities. They can also be abstract or concrete data structures, such as records, tuples or segments. An entity type can have any number (including zero) of attributes.

An entity type can be a subtype of one or several other entity types.

The Entity type properties dialog box (menu New/Entity type ...)

An entity type has the following features:

Name

:

to give a name to the entity type (mandatory, 100 characters);

Short name

:

to give a short name to the entity type (optional, 12 characters);

Length

:

indicates the total length of all its attributes; a “+” is added if the entity type plays roles (automatically update);

Supertypes

:

to add, remove or examine the super-types of the entity type;

Total

:

if checked, the sub-types are subject to the total constraint;

Disjoint

:

if checked, the sub-types are subject to the disjoint constraint;

Sem

:

to give a semantic description to the entity type;

Tech

:

to give a technical description to the entity type;

Prop

:

to give value(s) to the meta-properties of the entity type (for instance to the predefined stereotype meta-property).

Exit buttons

New ent.

:

to create a new entity type, saving changes to the current one;

New att.

:

to save changes and add a new attribute to this entity type;

Ok

:

to close the dialog box saving changes;

Cancel

:

to close the dialog box discarding changes.

An entity type is identified within a schema by its name.


Rel-type

A rel-type (relationship type) represents a class of associations between entities. It has two or more roles and any number (including zero) of attributes. A role is the partner of an entity type.

The Rel-type properties dialog box (menu New/Rel-type ...)

A rel-type has the following features:

Name

:

to give a name to the rel-type (mandatory, 100 characters);

Short name

:

to give a short name to the rel-type (optional, 12 characters);

Length

:

indicates the total length of all its attributes; a “+” is added if the rel-type has roles (automatically updated);

Sem

:

to give a semantic description to the rel-type;

Tech

:

to give a technical description to the rel-type;

Prop

:

to give value(s) to the meta-properties of the rel-type (for instance to the predefined stereotype meta-property).

Exit buttons

New rel.

:

to create a new rel-type, saving changes to the current one;

New role

:

to create a new role, saving changes to the rel-type;

New att.

:

to save changes and add a new attribute to this rel-type;

Ok

:

to close the dialog box saving changes;

Cancel

:

to close the dialog box discarding changes.

A rel-type is identified within a schema by its name.


Role

A role is a place holder in a rel-type. It is played by one or several entity types (mono-ET role or multi-ET role) and is given a cardinality constraint that states the minimum and maximum number times connected entities can play this role.

The Role properties dialog box (menu New/Role ...)

A role has the following features:

Name

:

to give a name to the role (100 characters, optional if only one entity type plays this role, mandatory otherwise);

Cardinality

:

to set the minimum and maximum cardinalities (mandatory, 0 min < N, min max and 1 max N);

Entity types

:

displays the list of entity type(s) that play this role;

Aggregation

:

if checked, the associated rel-type is an aggregation rel-type; this role is played by the owner (an entity type) of the aggregation;

Composition

:

if checked, the associated rel-type is a composition rel-type; the role is played by the owner (an entity type) of the components;

Sem

:

to give a semantic description to the role;

Tech

:

to give a technical description to the role;

Prop

:

to give value(s) to the meta-properties of the role.

Exit buttons

Next role

:

to create a new role, saving changes to the current one;

Ok

:

to close the dialog box saving changes;

Cancel

:

to close the dialog box discarding changes.

A role is identified within a rel-type by its name (if any) or by the name of the entity type playing the role (otherwise). The name of a multi-ET role is mandatory. The roles of a rel-type have distinct names.


Attribute

An attribute represents a property of entities or associations of the same type. It is either atomic or compound; an atomic attribute has a domain of values; each attribute is subject to a cardinality constraint [min-max]. This constraint allows to specify optional/mandatory (min = 0 or 1) attributes as well as single-valued/multivalued (max = 1 or > 1) attributes. The possible domains of values are listed below:

- boolean | : | represents a boolean.
- char | : | represents a character string. The length field gives the number of characters to be stored.
- compound | : | represents a compound attribute.
- date | : | represents a date.
- float | : | represents a floating point value. The length field gives the number of significant digits.
- index | : | represents an index. The length field gives the number of significant digits.
- numeric | : | represents a numeric value. The length field gives the length of the attribute without the sign and the decimal point, but with the digits on the right side of the decimal point. The decim field gives the number of digits on the right side of the decimal point.
- sequence | : | represents a sequence. The length field gives the number of significant digits.
- varchar | : | represents a varying character string. The field length gives the maximum number of characters to be stored; if the length field is set to N, there is no limit on the attribute length.
- object type | : | represents an entity type domain.
- user-defined | : | represents a user-defined domain.
A multivalued attribute has a collection type. The possible collection types are listed below:
- set | : | the values of the attribute are distinct and there is no ordering relation between them.
- bag | : | the values are not necessarily distinct and there is no ordering relation between them.
- unique list | : | the values are distinct and ordered.
- list | : | the values are not necessarily distinct but they are ordered.
- unique array | : | the values are distinct and ordered. Each value is stored into a cell and a cell can be empty.
- array | : | the values are not necessarily distinct but they are ordered. Each value is stored into a cell and a cell can be empty.

The Attribute properties dialog box (menu New/Attribute ...)

An attribute has the following features:

Name

:

to give a name to the attribute (mandatory, 100 characters);

Short name

:

to give a short name to the attribute (optional, 12 characters);

Cardinality

:

to set the minimum and maximum cardinalities of the attribute (mandatory, 0 min < N, min max and 1 max N);

Collection type

:

to select the collection type of the attribute (set, bag, unique list, list, unique array, array) (for multivalued attributes only);

Type

:

to select the type of the attribute (numeric, char, date, boolean, compound, float, varchar, sequence, index, object type or user-defined);

Stable

:

if checked, the attribute value cannot be changed;

Non Recyclable

:

if checked, the attribute value cannot be reused;

Length

:

to set the length of the attribute (only for numeric, float, char, varchar, index and sequence);

Decim

:

to set the length of the decimal part of a numeric attribute (only for numeric type);

Object type

:

to select the referenced entity type (only for object type);

User-def

:

to select the user-defined domain (only for user-defined type);

Sem

:

to give a semantic description to the attribute;

Tech

:

to give a technical description to the attribute;

Prop

:

to give value(s) to the meta-properties of the attribute (for instance to the predefined meta-properties: default value, value constraint and stereotype).

Exit buttons

First att.

:

to save changes and create the first attribute of this attribute (only for compound attributes);

Next att.

:

to save changes and create a new sibling attribute of the current one;

Ok

:

to close the dialog box saving changes;

Cancel

:

to close the dialog box discarding changes.

An attribute is identified among its siblings (attributes of an entity type, a rel-type or a compound attribute) by its name.


Group

A group is associated to a parent object (entity type, rel-type or multivalued compound attribute). A group is a set of attributes and/or roles and/or other groups that play some functions together for the parent object. The possible functions of a group include: identifier, coexistence, exclusive, at-least-one, user constraint and access key.

The Group properties dialog box (menu New/Group ...)

A group has the following features:

Name

:

to give a name to the group (mandatory, 100 characters);

Length

:

indicates the total length of all the group components; a “+” is added if it contains roles (automatically updated);

Primary ID

:

if checked, the group is a primary identifier;

Secondary ID

:

if checked, the group is a secondary identifier;

Coexistence

:

if checked, the group is a coexistence group (the group components must be simultaneously present or absent in any instance of the parent object);

Exclusive

:

if checked, the group is an exclusive group (at most one of the group components can be present in any instance of the parent object);

At-least-one

:

if checked, the group is an at-least-one group (at least one of the group components must be present in any instance of the parent object);

User const.

:

if checked, the group is a user constraint group (the exact expression of this constraint can be stored in the semantic description of the group); a name must be given to this constraint;

Access key

:

if checked, the group is an access key group (the group components form an access mechanism to the instances of the parent object);

Min.

:

to set the minimum cardinality of the group;

Max.

:

to set the maximum cardinality of the group;

Component

:

to select the group components (attributes, roles or groups); the components can also come from the super-types of the group owner;

Sem

:

to give a semantic description to the group;

Tech

:

to give a technical description to the group;

Prop

:

to give value(s) to the meta-properties of the group.

Exit buttons

Constraint

:

to save changes and create a constraint for this group;

Ok

:

to close the dialog box saving changes;

Cancel

:

to close the dialog box discarding changes.

A group is identified within its parent (entity type, rel-type or compound attribute) by its name.


Constraint

An integrity constraint is associated with a (origin) group and refers to another (target) group. Some of them are: referential (ref), referential with equivalence (ref equ), inclusion (incl), inverse (inv) and generic.

The Constraint properties dialog box (menu New/Constraint ...)

A constraint has the following features:

Ref

:

if checked, the constraint is a foreign key;

Ref equ

:

if checked, the constraint is a foreign key with an equality constraint;

Inclusion

:

if checked, the constraint is an inclusion: each instance of the first group must be an instance of the second group (the second group cannot be an identifier; the inclusion constraint is the generalization of the referential constraint);

Inverse

:

if checked, each object attribute is the inverse of the other;

Generic

:

if checked, the constraint is a generic constraint between two groups without preconditions;

Target object

:

to choose the objet containing the target group;

Target group

:

to choose the target group.

Exit buttons

Remove

:

to remove the constraint;

Ok

:

to close the dialog box saving changes;

Cancel

:

to close the dialog box discarding changes.


Processing unit/Action State/Use Case

In a data schema (ER or UML Class Diagram), an anchored processing unit is any dynamic or logical component of the described system that can be associated with a schema, an entity-type or a relationship type.
In a UML Activity Diagram, a processing unit is a generic component representing various kinds of action states:
 | an action state is a shorthand for a state with an entry action and at least one outgoing transition involving the implicit event of completing the entry action.
 | an initial state is a special kind of action state that represents the beginning of an activity diagram.
 | a final state is a special kind of action state that represents the completion of an activity diagram.
 | a synchronization state, either horizontal or vertical allows to synchronize concurrent regions. It is used in conjunction with forks and joins to insure that one region leaves a particular state before another region can enter a particular state.
 | a decision state is expressed when conditions are used to indicate various possible transitions that depend on boolean conditions.
 | a signal sending shows a transition sending a signal.
 | a signal receipt shows a transition receiving a signal.
In a UML Use Case Diagram, a processing unit represents a use case. A use case is a kind of classifier representing a coherent unit of functionality provided by a system, a subsystem, or a class.

The Processing unit/Action state/Use case properties dialog box (menu New/… ...)

A processing unit/action state/use case has the following features:

Name

:

to give a name to the object (mandatory, 100 characters);

Short name

:

to give a short name to the object (optional, 12 characters);

Type

:

to select the type of the processing unit/action state/use case (available types are: method, predicate, trigger and procedure);

Sem

:

to give a semantic description to the object;

Tech

:

to give a technical description to the object;

Prop

:

to give value(s) to the meta-properties of the object (for instance to the predefined stereotype meta-property).

Relations

:

to create, remove or update the relationships of an action state (control flow or object flow) or a use case (extend, include, use case generalization, association)

Exit buttons

New ....

:

to save changes and create another processing unit/action state/use case;

Ok

:

to close the dialog box saving changes;

Cancel

:

to close the dialog box discarding changes.

A processing unit/action state/use case is identified within its parent (entity type, rel-type or schema) by its name.


Object

In a UML Activity Diagram, there are two kinds of objects:

 | an internal object can be a data type, a variable, a constant or any object that is known by the action states of the schema but that is unknown outside;
 | an external object is defined in a data schema and used in a UML Activity Diagram. Such is the case of entity types, attributes, collections or rel-types.
Objects are used as input or output of action states.

The Internal object dialog box (menu New/Object ...)

An internal object has the same properties as an attribute.

The External object dialog box

An external object (i.e. an entity type, a rel-type, an attribute or a collection) is defined in a data schema via the corresponding dialog box. To use an external object in a UML Activity Diagram, an object flow relationship must be created by clicking the relations button in the property box of an action state.


State

In an UML Activity Diagram, a state (or object state) is a picture of an object at a precise time. In fact, an object that can be transformed during the process described by the activity diagram can be in a different state before and after one of the actions. For instance, a glass can be empty before the action of filling it, and full after that action. Since only the empty glass can be put in a cupboard and only the full glass can be drunk, it is important, for other actions, to distinguish the various states of the object.

The State properties dialog box

A state has the following features:

Name

:

to give a name to the state (mandatory, 100 characters);

Short name

:

to give a short name to the state (optional, 12 characters);

Sem

:

to give a semantic description to the state;

Tech

:

to give a technical description to the state;

Prop

:

to give value(s) to the meta-properties of the state (for instance to the predefined stereotype meta-property);

Object

:

to open the property box of the object in the current state;

Relations

:

to create, remove or update the object flow relations of the state.

Exit buttons

New state

:

to create a new state, saving changes to the current one;

Ok

:

to close the dialog box saving changes;

Cancel

:

to close the dialog box discarding changes.

A state is identified within a schema by its name and the name of the associated object.


Actor

In a UML Use Case Diagram, an actor represents a coherent set of roles that users can play when interacting with a system. An actor materializes any resource (man, machine, ...) that can be associated with an action. For instance, the employee who gives a phone call is an actor.

The Actor properties dialog box

An actor has the following features:

Name | : | to give a name to the actor (mandatory, 100 characters);
Short name | : | to give a short name to the actor (optional, 12 characters);
Type | : | not used so far;
Sem | : | to give a semantic description to the state;
Tech | : | to give a technical description to the state;
Prop | : | to give value(s) to the meta-properties of the state (for instance to the predefined stereotype meta-property);
Relations | : | to create, remove or update the association relations or the actor generalization relations of the actor.

Exit buttons

New actor | : | to create a new actor, saving changes to the current one;
Ok | : | to close the dialog box saving changes;
Cancel | : | to close the dialog box discarding changes.

An actor is identified within a schema by its name.


Relation

In a UML Activity Diagram, a relation describes how an action state relates to other action states and to internal and external objects (attributes, entity types, rel-types or collections). There are two kinds of relationships:

 | a control flow indicates the order of execution of action states;
 | an object flow indicates input object states or output objects (internal or external) of an action state when the latter uses/reads object states and creates/deletes/updates others.
In a UML Use Case Diagram, a relationship describes how a use case relates to others, and how actors are associated with use cases. There are five kinds of relationships:
 | an extend relationship from a use case A to a use case B indicates that an instance of B may be augmented by the behavior specified by A;
 | an include relationship from a use case A to a use case B indicates that an instance of A will also contain the behavior specified by B;
 | a use case generalization from a use case A to a use case B indicates that A is a specialization of B
 | an association between a use case and an actor indicates the participation of an actor in a use case;
 | an actor generalization from an actor A to an actor B indicates that an instance of A can communicate with the same kinds of use-case instances as can do an instance of B.

The Relationship properties dialog box

A relationship has the following features:

Data schema (object flow relations only):

:

to select the schema (a data schema or the current UML Activity Diagram) from which objects can be selected in order to be used in a data flow relation;

Add

:

to add an object or a processing unit to the current processing unit;

In (object flow relations only)

:

if checked, the Add button adds an object as input of the current action state;

Out (object flow relations only)

:

if checked, the Add button adds an object as output of the current action state;

Update (object flow relations only)

:

if checked, the Add button adds an object as updatable (input/output) by the current action state;

UC card. (association relations only)

:

to set the minimum and maximum number of instances of the current use case into which each actor can participate;

Actor card. (association relations only)

:

to set the minimum and maximum number of actors that can participate in each occurrence of the use case;

Remove

:

to remove an object, an action state, a use case or an actor from the current action state or use case (depending on the kind of relation);

Components

:

shows the list of action states, object states, use cases or actors associated with the current relation;

Prop

:

to give value(s) to the meta-properties of the relation (for instance to the predefined stereotype meta-property).

Exit buttons

Ok

:

to close the dialog box saving changes;

Cancel

:

to close the dialog box discarding changes.


Semantic and Technical descriptions

DB-MAIN allows two types of descriptions:

          •

    A semantic description is a free text of arbitrary length. It is intended to give an informal description of the associated object.

  • A technical description is a free text of arbitrary length. It is intended to give technical information on the associated object. Its content and exact meaning depends on the class of the object, on the methodology that is carried out and on the designer's goals.


Note

In a data or processing schema, as well as in the project window (history), a note is a kind of post-it that can be inserted in a schema or attached to some objects of a schema. In graphical views, a note appears as a small box with a folded corner and some free text inside. The links between a note and its owners are represented by dotted lines, except for those associated to schemas. In textual views, the first line of a note appears below its owner.

Notes can be attached to the following objects: schemas, collections, entity types, rel-types, attributes, groups, roles, processing units, action states, objects, control flows, object flows, synchronizations, decisions, initial/final states, object states, signal sendings, signal receipts, use cases, actors, extend relationships, include relationships, use case generalizations, associations and actor generalizations.

The Modify note dialog box (menu New/Note ...)

A note has the following features:

Text field | : | to give a textual content to the note (free text in natural language);
Connect | : | to open the Note connections dialog box (see below), thus editing the list of objects to which the note is attached;
Ok | : | to close the dialog box saving changes;
Cancel | : | to close the dialog box discarding changes.

The Note connections dialog box

The note is attached to: |
 |  | displays the list of objects to which the note is attached;
The note can be attached to: |
 |  | displays the list of objects to which the note can be attached;
Add | : | to add the item selected in the list of candidates to the list of objects to which the note is attached;
Remove | : | to remove the selected element from the list of objects to which the note is attached;
Show only if all owners are shown:
 |  | if checked, the note will be displayed only if all the objects to which it is attached are shown in the schema window (some objects can be hidden via the graphical settings); if not checked, the note will be displayed as soon as one of the objects to which it is attached is shown in the schema window;
Ok | : | to close the dialog box saving changes;
Cancel | : | to close the dialog box discarding changes;


Transformations (definitions)

Transformation

A transformation T is an operator that replaces a source construct C in a schema S with another construct C'. C' is the target of C through T, and is noted C' = T(C). T is associated to preconditions that any construct C must satisfy in order to be transformed by T.

Reversibility

A transformation T1 is reversible if there exists a transformation T2 such that, for any construct C, T2(T1(C)) = C. The notion of reversibility is an important feature of transformations. If a transformation is reversible, source and target schemas have the same descriptive power, they represent the same universe of discourse, although possibly with a different presentation (syntax).

So far, every transformation included in DB-MAIN is reversible, except for split/merge, unprefix and conversion of a multivalued attribute.

See also:

Elementary transformations, global transformations.


Elementary transformation

Elementary transformations

An elementary transformation allows to perform one single transformation on the current object.

Some properties (often the name, short name and descriptions) of the new object(s) created by the transformation can be modified through dialog boxes. The Ok button confirms the transformation, the Cancel button cancels it. Some complex transformations have specific dialog boxes. These are detailed in the corresponding transformation description.

Transformations can be customized through pre- and post-processing.

The various elementary transformations are listed below:

Transformation of entity types:

Transform an entity type into a rel-type

Transform an entity type into an attribute

Transform is-a relations of a super-type into rel-types

Transform one-to-one rel-types of an entity-type into is-a relations

Split/merge entity types

Add a technical identifier

Transformation of rel-types:

Transform a rel-type into an entity type

Transform a rel-type into an attribute

Transform a rel-type into an object type attribute

Transformation of attributes:

Transform an attribute into an entity type

Transform an object type attribute into a rel-type

Disaggregate a compound attribute

Transform a multivalued attribute into a single-valued attribute

Transform a single-valued attribute into a multivalued attribute

Transform a multivalued attribute into a list of single-valued attributes

Convert a multivalued attribute

Materialize the user-defined domain of an attribute

Transformation of roles:

Transform a multi-ET role into rel-types

Transformation of groups:

Transform a group (foreign key) into a rel-type

Aggregate a list of attributes

Transform a group of attributes into a multivalued attribute

Other:

Change the prefix of every attribute of an entity type, a rel-type or a compound attribute


Transformation of an entity type into a rel-type

Transform an entity type into a rel-type

Principle

An entity type E linked to other entity types by one-to-many rel-types is transformed into a rel-type.

Preconditions

          •

    E has no generalization/specialization relations (messages 1 and 2).

  • E does not belong to a collection (message 3).

  • E plays at least two roles. All of them are mono-ET and their cardinality is [1-1] (messages 4, 5 and 6). If E belongs to an UML class diagram, it plays exactly two roles (message 7).

  • Ri (1 £ i £ n) are binary, non-cyclic, have no attributes or processing units (message 8).

  • E has an identifier. This identifier can be implicit (the role of a one-to-one rel-type) (message 9).

  • E does not contain groups involved in matching constraints (reference, ...) (message 10).

  • The cardinality of all attributes that belong to identifiers of E is [1-1] (message 11).

    Rationale

    If E has generalization/specialization relation(s) and/or belongs to a collection and/or contains groups involved in matching constraints, all this information would be lost after transforming E into R.

    A rel-type has always at least two roles; therefore E must be linked to at least two rel-types. All attributes of a rel-type that belong to identifiers are mandatory and single-valued.

    Messages

    1 | "This entity type cannot have subtype(s)."
2 | "This entity type cannot have super-type(s)."
3 | "This entity type cannot belong to a collection."
4 | "This entity type must play at least two roles."
5 | "The cardinality of all roles played by this entity type must be [1-1]."
6 | "Every role played by this entity type must be mono-ET."
7 | "This entity type (belonging to an UML class diagram) must play two roles."
8 | "Every rel-type linked to this entity type must be binary, acyclic, cannot have attributes or processing units."
9 | "This entity type must have an identifier."
10 | "This entity type cannot contain groups involved in matching constraints."
11 | "Every attribute that belongs to identifiers of this entity type must be mandatory and single-valued."

    Postconditions

          •

    A new rel-type is created (R).

  • Attributes, groups, processing units, meta-properties values and notes of E are transferred to R.

  • Every group of Ei (1 £ i £ n) that contains the component rei is deleted.

  • roi (1 £ i £ n) are transferred from Ri to R. Ri and rei (1 £ i £ n) are deleted.

  • Identifiers composed of only all roi (1 £ i £ n) or only one role with a maximum cardinality of 1 are deleted (they are implicit identifiers of R) except for those involved in a matching constraint or having other properties (coexistence, exclusive, at-least-one, user-constraint or access key).

  • E is deleted.

    Rationale

    Every group of Ei (1 £ i £ n) that contains the role rei (1 £ i £ n) is deleted. These groups cannot be identifiers because the maximum cardinality of rei is 1. They are only access keys or something else.

    Example


Transformation of an entity type into an attribute

Transform an entity type into an attribute

There are two cases:

Transform an entity type into an attribute of an entity type

Transform an entity type into an attribute of a rel-type


Transformation of an entity type into an attribute of an entity type

Transform an entity type into an attribute of an entity type

Principle:

An entity type E1 that is linked to only one other entity type E2 is transformed into an attribute of E2.

Case 1: E1 has only one attribute

Case 2: E1 has several attributes

Preconditions

E1 has no generalization/specialization relations (messages 1 and 2).

E1 does not belong to a collection (message 3).

E1 plays only one role (the cardinality of r1 is [1-j1]) with R. R is binary, non-cyclic, has no attributes or processing units and its roles are mono-ET (messages 4, 5, 6 and 7).

E1 has at least one attribute (message 8).

E1 has no processing units (message 9).

E1 has no identifiers referenced in matching constraints (reference, etc) unless R is one-to-one (message 10).

If r1 belongs to an identifier of E2, the cardinality of the new attribute A1 replacing r1 will be [1-1] for a primary identifier and [0-1] or [1-1] for secondary identifiers (message 11).

If the maximum cardinality of r2 is more than 1 and the cardinality of r1 is [1-1], E1 cannot have an identifier composed of a subset of its attributes (message 11).

If the maximum cardinality of r1 is more than 1, E1 must have an identifier (message 12).

Warning: if this identifier does not contain all attributes of E1, a functional dependency will be lost after transformation (message 13).

Rationale

If an identifier of E2 contains r1, this role is replaced by a new attribute A1. The cardinality of this attribute is [0-1] or [1-1] (for a primary identifier). If A1 is multivalued, a requirement is violated (a multi-component identifier cannot contain a multivalued attribute).

If E1 contains groups that reference identifiers of other entity types, these groups are transferred to E2. But if E1 has identifiers that are referenced by groups of other entity types, these identifiers must identify E2 as well. It is only possible if R is one-to-one.

In some cases, identifiers of E1 lead to some problems. Such critical cases are described below.

Non-preserving transformation is stopped:

If the identifier of A is a subset of its attributes (more than one and less than all), the transformation is cancelled because an identifier with two multivalued attributes (A[*].A1 and A[*].A2) cannot be created in B.

Non-preserving transformation is stopped:

The entity identity would be lost after transformation. Re-transforming A[i-j] into an entity type through value representation would create a compound identifier (A1 and A2).

Non-preserving transformation with warning:

The functional dependency (A1 -> A2) is lost. Re-transforming A[i-j] into an entity type through value representation would create a compound identifier (A1 and A2).

Messages

1 | "This entity type cannot have subtype(s)."
2 | "This entity type cannot have super-type(s)."
3 | "This entity type cannot belong to a collection."
4 | "This entity type must play only one role."
5 | "The minimum cardinality of the role played by this entity type must be 1."
6 | "The rel-type linked to this entity type must be binary, non-cyclic and cannot have attributes."
7 | "The rel-type linked to this entity type must have only mono-ET roles."
8 | "This entity type must have at least one attribute."
9 | "This entity type cannot have processing unit(s)."
10 | "If this entity type has identifier(s) referenced in matching constraints, its only role must be part of a one-to-one rel-type."
11 | "Non-preserving transformation: a non-minimal identifier would be generated."
12 | "Non-preserving transformation: the entity identity would be lost."
13 | "Warning: Non-preserving transformation, a functional dependency will be lost."

Postconditions

Case 1: the cardinality of r2 is [0-1] or [1-1] and E2 has a multivalued attribute or E1 has only one single-valued attribute.

A1 is transferred to E2.

The new cardinality of A1 is the product of its old cardinality and the cardinality of r2.

If j2 > 1, the cardinality of r1 is [1-1] and E1 has no identifier; the collection type of A1 is bag.

if j1 = 1, the values of the meta-properties of E1 are transferred to A1, otherwise (j1 > 1) the values of the meta-properties of R are transferred to A1.

The notes of E2 are transferred to A1.

Case 2: (E1 contains several attributes) or (j2>1 and E2 contains a multivalued attribute).

A compound attribute A1 is created in E2. This attribute takes the name of E1.

A11, ..., A1n become sub-attributes of A1.

The cardinality of A1 is [i2-j2].

If j2 > 1, the cardinality of r1 is [1-1] and E1 has no identifier; the collection type of A1 is bag.

if j1 = 1, the values of the meta-properties of E1 are transferred to A1, otherwise (j1 > 1) the values of the meta-properties of R are transferred to A1.

The notes of E2 are transferred to A1.

R1 is replaced by A1 in all groups of E2.

If the cardinality of r1 is [1-1], for each identifier of E1:

if the maximum cardinality of r2 is 1, the identifier is transferred to E2.

if the maximum cardinality of r2 is greater than one and if r2 belongs to the identifier, the latter becomes an identifier of EA1.

if the maximum cardinality of r2 is greater than one and if the identifier contains only one attribute, this identifier is transferred to E2 and the attribute becomes an identifier of EA1 (see transform an attribute into entity type).

if the maximum cardinality of r2 is greater than one and if the identifier contains all the attributes of E1, EA1 becomes an identifier of E2.

The remaining groups of E1 (except for identifiers having no other functions) that are composed of attributes of E1 only are transferred to E2. The identifier function (if exists) is removed from these groups.

E1 and R are deleted.

Rationale

Every group (other than identifiers) of E1 that contains r2 is deleted. These groups can only be access keys. Since the minimum cardinality of r1 is 0, these groups cannot be exclusive, coexistence or at-least-one groups.

If j2 >1, the cardinality of r1 is [1-1] and E1 has no identifier; the collection type of the created attribute is bag. Before transformation, E2 is linked to many E1 that possibly have identical attribute values (E1 has no identifier). After transformation, the new attribute of E2 is a multivalued bag attribute (several elements can be identical).

Example


Transformation of an entity type into an attribute of a rel-type

Transform an entity type into an attribute of a rel-type

Principle

An entity type E1 that plays a role in a rel-type R (at least ternary) is transformed into an attribute of R.

Case 1: E1 has only one attribute

Case 2: E1 has several attributes

Preconditions

E1 has no generalization/specialization relations (massages 1 and 2).

E1 does not belong to a collection (message 3).

E1 plays only one role (r1) with R. This role is mono-ET and its cardinality is [1-j1]. R is at least ternary (messages 4 and 5).

E1 has at least one attribute (message 6).

E1 has no processing units (message 7).

The cardinality of every direct attribute of E1 is [1-1] (message 8).

E1 has an identifier that contains all its direct attributes (message 9).

E1 has no identifiers referenced in matching constraints (reference, …) (message 10).

Rationale

If r is an instance of R, r is always related to three instances (one of E1, one of E2 and one of E3). If the cardinality of r1 is [0-j1], E1 will be transformed into an optional attribute. In this case, an instance of R is related to two instances (one of E1 and one of E3) and has an optional attribute. This schema does not bear the same semantics.

Messages

1 | "This entity type cannot have subtype(s)."
2 | "This entity type cannot have super-type(s)."
3 | "This entity type cannot belong to a collection."
4 | "This entity type must play only one mono-ET mandatory role."
5 | "The rel-type linked to this entity type must be at least ternary."
6 | "This entity type must have at least one attribute."
7 | "This entity type cannot have processing unit(s)."
8 | "Every direct attribute of this entity type must be single-valued and mandatory."
9 | "The direct attribute(s) of this entity type must form together an identifier (without other components)."
10 | "This entity type cannot contain groups referenced in matching constraints."

Postconditions

Case 1: E1 has only one single-valued attribute.

A1 is transferred to R.

The cardinality of A1 does not change.

The values of the meta-properties of E1 are transferred to A1.

The notes of E1 are transferred to A1.

Case 2: E1 has several attributes.

A compound attribute A1 is created in R. This attribute takes the name of E1.

A11, ..., A1n become sub-attributes of A1.

The cardinality of A1 is [1-1].

The values of the meta-properties of E1 are transferred to A1.

The notes of E1 are transferred to A1.

r1 is replaced by A1 in all groups of R.

The groups of E1 (other than identifiers) that contain only attributes of E1 are transferred to R.

If the cardinality of r1 is [1-1], the identifier of E1 is transferred to R (it becomes a secondary identifier if R has already a primary one).

If R has no identifiers and if the maximum cardinality of all its roles is greater than 1, a primary identifier of R composed of all its roles and the transferred attribute is created.

If R has an identifier that contains only all its roles, this identifier is implicit and is therefore deleted.

E1 is deleted.

Rationale

See transform an attribute of a rel-type into an entity type.

Example


Transformation of is-a relations of a super-type into rel-types

Transform is-a relations of a super-type into rel-types

Principle

One-to-one rel-types can replace is-a relations of a super-type.

Preconditions

EG has subtype(s) ESi (1 £ i £ n) (message 1).

ESi (1 £ i £ n) do not have groups containing components that will be invalid after transformation (message 2).

If the cluster is subject to the disjoint, total or partition property, EG has more than one sub-type (message 3).

Rationale

An invalid component of a group is an attribute, group or role belonging to a super-type of ESi (1 £ i £ n) that would no longer be linked to ESi by an is-a relation after transformation.

If EG has only one sub-type and is subject to the disjoint, total or partition property, the transformation would create an exclusive, at-least-one or exactly-one group containing only one role.

Messages

1 | "This entity type must have subtype(s)."
2 | "The sub-types cannot have groups that contain attributes, roles or groups of their super-type (and its super-types)"
3 | "This entity-type must have more than one sub-type to satisfy the disjoint, total or partition property."

Postconditions

Every ESi (1 £ i £ n) is linked to EG by a rel-type Ri. These new rel-types replace the cluster. The notes linked to the cluster are duplicated and connected to the new rel-types. These rel-types are given the «subt» stereotype.

The cardinality of the role played by EG in Ri (1 £ i £ n) is [0-1]

The cardinality of the role played by ESi (1 £ i £ n) in Ri is [1-1]

If necessary, a group composed of the roles played by ESi (1 £ i £ n) in Ri is added to EG.

If the cluster has the disjoint property, the new group is submitted to the exclusive constraint.

If the cluster has the total property, the new group is submitted to the at-least-one constraint.

If the cluster has the partition property, the new group is submitted to both the exclusive and the at-least-one constraints (i.e. the exactly-one constraint).

The cluster is deleted.

Example


Transformation of one-to-one rel-types of an entity-type into subtypes

Transform one-to-one rel-types of an entity-type into subtypes

Principle

Is-a relations can replace one-to-one rel-types.

Preconditions

EG is linked to one-to-one rel-types (Ri (1 £ i £ n)) that have only mono-ET roles and neither attributes nor processing units. The cardinality of the role played by EG in Ri (1 £ i £ n) is [0-1] and that of the role played by ESi (1 £ i £ n) is [1-1] (message 1).

If EG contains exclusive and/or at-least-one groups composed of roles played by ESi (1 £ i £ n) in Ri, these groups cannot contain attributes or roles that belong to complex rel-types (one-to-many or many-to-many rel-types, rel-types containing attributes or processing units) (message 2).

Warning: If one or several ESi (1 £ i £ n) have groups containing roles played by EG in Ri, these groups can become inconsistent. Such groups can only be access keys or groups without any function (message 3).

Rationale

An exclusive and/or at-least-one group of EG containing Ri.Esi (1 £ i £ n) roles is replaced by a cluster property (disjoint and/or total) after transformation. If such a group contains attributes or roles of complex rel-types, it would become inconsistent after transformation.

Messages

1 | "This entity type must be linked to one-to-one rel-type(s) that have neither attributes nor processing units."
2 | "The roles of the one-to-one rel-types (without attributes and processing units) cannot belong to exclusive and/or at-least-one groups (of this entity type) containing attributes or roles of other complex rel-types."
3 | "Warning: If the roles (belonging to one-to-one rel-types and played by this entity type) are contained in groups, these groups can become inconsistent."

Postconditions

Ri (1 £ i £ n) are replaced by is-a relations between EG and ESi (1 £ i £ n). The notes of Ri (1 £ i £ n) are transferred to the new cluster.

If the roles played by ESi (1 £ i £ n) in Ri belong to a group of EG submitted to the at-least-one or exclusive constraint(s):

If the group is submitted to the exclusive constraint, the cluster is given the disjoint property.

If the group is submitted to the at-least-one constraint, the cluster is given the total property.

If the group is submitted to both the exclusive and the at-least-one constraints, the cluster is given the partition property.

Ri (1 £ i £ n) are deleted.

Example

Dialog box

The dialog box associated to this transformation has the following features:

Rel-types | : | displays the list of rel-types linked to the current entity type that can be transformed into is-a relations;
Is-a | : | displays the list of rel-types that will be transformed into is-a relations;
Add | : | to transfer the selected items from the Rel-types list box to the Is-a list box;
Remove | : | to transfer the selected items from the Is-a list box to the Rel-types list box;
Ok | : | to execute the transformation;
Cancel | : | to cancel the transformation.


Split/Merge entity types

Two transformations (splitting and merging) are grouped together to form a complex one.

Before executing the transformation itself, it is necessary to choose whether to create a new entity type ESM1 (splitting) or use an existing one (partial or total merging).

These transformations are described separately:

Split an entity type

Merge (totally or partially) two entity types


Split an entity type

Principle

The attributes and roles of an entity type are divided into two entity types. These entity types are linked by a one-to-one rel-type.

Precondition

ESM has attribute(s) and/or processing unit(s) and/or role(s) (message 1).

Message

1

"This entity type must have attribute(s), processing unit(s) or role(s)."

Rationale

The user chooses which components of ESM he wants to transfer to ESM1. Of course, all the components of a group must be transferred together.

In the example below, if A5 is transferred into E2, A2, A3 and A4 must be transferred as well.

Postconditions

A new entity type ESM1 is created.

A new rel-type RSM linking ESM and ESM1 is created. The cardinality of its roles is [1-1].

Every component (attributes, processing units and/or roles) of ESM selected by the user is transferred to ESM1.

Every group that contains one or several of these components is transferred to ESM1.

ESM1 (resp. ESM) and RSM are deleted if ESM1 (resp. ESM) has no attributes or processing units and plays only the role r2 (resp. r1).

Additional rules

If all the attributes and roles (except r2) of E2 belong to a coexistence group, the cardinality of r1 is set to [0-1] and the minimum cardinality of the attribute(s) and role(s) of E2 (except r2) is set to 1.

If E2 has only one attribute and plays only one role (r2), the cardinality of r1 is set to [0-1] and the minimum cardinality of its attribute is set to 1.

Example

Dialog box

The dialog box associated to this transformation has the following features:

Left entity type name | : | displays the name of the current entity type;
Left list box | : | displays the list of attribute(s) and role(s) of the current entity type;
Rel-type name | : | to set the name of the new binary one-to-one rel-type;
Right entity type name | : | to set the name of the new entity type;
Right list box | : | displays the list of attribute(s) and role(s) that will be transferred from the current entity type to the new entity type;
Add first | : | to transfer the selected items from the left list box to the beginning of the right list box;
Add next | : | to transfer the selected items from the left list box to the end of the right list box (or after the selected item, if any);
Remove | : | to transfer the selected items from the right list box to the left list box;
Merge | : | to transfer all the items of the right list box to the left list box;
Ok | : | to execute the transformation;
Cancel | : | to cancel the transformation.


Merge (totally or partly) two entity types

Merge (totally or partially) two entity types

Principle

Given two entity types linked by a one-to-one rel-type, some (or all) attributes, processing units and roles of one of these entity types are transferred to the other one.

Preconditions

RSM is binary, one-to-one, and non-cyclic

The cardinality of r2 is [1-1].

ESM has no generalization/specialization relations.

r1 and r2 are mono-ET.

r2 does not appear in groups of ESM and r1 does not appear in groups of ESM1.

If the cardinality of r1 is [0-1], the minimum cardinality of the direct attribute(s) and role(s) of ESM1 is 1.

Rationale

Let us consider the following schema:

Transferring A3 to E2 produces the following schema:

This transformation does not allow to solve other patterns of this kind. Indeed, it is more complicated to deal with exclusive, at-least-one or access key groups since they often conceal some conceptual problems. In our example, the best schema is the second one.

Postconditions

Every component (attributes, processing units and/or roles) of ESM (resp. ESM1) selected by the user is transferred to ESM1 (resp. ESM).

Every group that contains one or several of these components is transferred accordingly.

ESM1 (resp. ESM) and RSM are deleted if ESM1 (resp. ESM) has neither attributes nor processing unit and plays only the role r2 (resp. r1).

Note

If the cardinality of r1 is [0-1], all the components of E2 (except r2) are submitted to an implicit coexistence constraint.

Transferring A3 to E1 produces the following schema:

This solution is correct but some problems may occur if A1 is transferred to E1. The coexistence constraint cannot be correctly defined any more. Consequently, if A3 is transferred to E1, all the other components of E2 (except the role r2) are transferred to E1 too. In fact the first schema is equivalent to the following one:

Example

Dialog boxes

The first dialog box associated to this transformation displays the list of entity types that can be merged with the current one. It has the following features:

List box | : | displays the list of all entity types that can be merged with the current one;
Ok | : | to merge the current entity type with the one selected in the list box (see the second dialog box);
New | : | to split the current entity type (see Split an entity type);
Cancel | : | to cancel the transformation.
The second dialog box associated to this transformation has the following features:
Left entity type name | : | displays the name of the current entity type;
Left list box | : | displays the list of attribute(s) and role(s) of the current entity type;
Rel-type name | : | displays the name of the binary one-to-one rel-type linking the current entity type to the one it will be merged with;
Right entity type name | : | displays the name of the entity type that will be merged with the current one;
Right list box | : | displays the list of attribute(s) and role(s) of the entity type that will be merged with the current one;
Add first | : | to transfer the selected items from the left list box to the beginning of the right list box;
Add next | : | to transfer the selected items from the left list box to the end of the right list box (or after the selected item, if any);
Remove | : | to transfer the selected items from the right list box to the left list box;
Merge | : | to transfer all the items of the right list box to the left list box;
Ok | : | to execute the transformation;
Cancel | : | to cancel the transformation.


Add technical identifier

Add a technical identifier

Principle

A technical primary identifier is added to the current entity type.

Postcondition

E has a technical primary identifier (IDE) and the former primary identifier (if any) becomes a secondary identifier.

Example


Transformation of a rel-type into an entity type

Transform a rel-type into an entity type

Principle

A rel-type R is transformed into an entity type E, its roles are transformed into rel-types.

Preconditions

roi (1 £ i £ n) do not belong to groups of Ei (message 1).

R plays at least two roles (message 2).

Rationale

If roi (1 £ i £ n) belongs to a group of Ei, the transformation would create a "path" group. DB-MAIN does not allow this concept.

Messages

1 | "Roles of this rel-type cannot belong to groups of entity types linked to this rel-type."
2 | "This rel-type must play at least two roles."

Postconditions

R is replaced by a new entity type E. This entity type takes the name of R. Attributes, processing units, values of meta-properties and notes of R are transferred to E. Groups (except for identifiers composed of only one role, the maximum cardinality of which is 1 and that have no other properties or constraints) are transferred the same way.

If E has no primary identifier and if the maximum cardinality of the roles played by Ei (1 £ i £ n) in Ri is N, these roles form together a primary identifier of E.

Each roi (1 £ i £ n) is connected to its corresponding Ri and new roles rei (cardinality [1-1]) are created to link E and Ri.

R is deleted.

Example


Transformation of a rel-type into an attribute

Principle

A rel-type is replaced by a referential group in the referencing entity type. This group is made up of the attributes that compose the referenced identifier in the target entity type.

Preconditions

R is binary and has neither attributes nor processing units (message 1).

Both roles of R are mono-ET (message 2).

E2 has an identifier made up of attributes (id21, ..., id2n) (message 3).

(id21, ..., id2n) are not object type attributes (message 4).

If j1 > 1 and j2 = 1, E2 has a primary identifier composed of only one attribute (message 5).

Rationale

If j1 > 1, j2 = 1 and E2 has a primary identifier made of several attributes, the transformation would produce a multi-component identifier in E1. This identifier would contain multivalued attributes, which is not allowed in our representation model.

Messages

1

"This rel-type must be binary and cannot have attributes or processing units."

2

"Both roles of this rel-type must be mono-ET."

3

"The referenced entity-type must have an all-attribute primary identifier."

4

"The attribute(s) of the referenced identifier cannot be object type."

5

"The referenced entity type must have a primary identifier made of only one attribute."

Note

The groups of E2 that contain r1 are lost. These groups must have the access key, exclusive, at-least-one or coexistence function.

The referenced identifier cannot contain object type attributes because our representation model does not allow referential constraints containing object type attributes.

Postconditions

id21, ..., id2n are copied to E1 together with their notes and meta-properties values. Their cardinality is [i1-j1] (1 £ i £ n). If R has the «subt» stereotype, the Supertype meta-property of the new group gets E2 as a new value and the Subtypes meta-property of the identifier of E2 gets E1 as a new value.

A group composed of id21, ..., id2n is created in E1. If j2 = 1, this group is an identifier of E1 (primary if E1 has no primary identifier and if i1 = 1, secondary otherwise). If i1 = 0, this group is also a coexistence group. The cardinality of the group is [i2-j2].The values of the meta-properties of R are transferred to the new group.

r2 is replaced by id21, ..., id2n in multi-component constraint groups of E1 and in constraint groups of E1 containing inner groups. Groups that contain r2 only and that are not submitted to a constraint are deleted and their properties (identifier, coexistence, exclusive, at-least-one, user-defined and access key) are transferred to the new group.

If a group of E1 is involved in an inclusion constraint and if the two groups (of the inclusion constraint) verify the required conditions to form a referential constraint (components are attributes, target group is identifier, ...), the inclusion constraint becomes a referential constraint.

A referential constraint is created in E1. Its source is the new group and its target is the identifier of E2. If i2 = 1, the referential constraint is an equality, otherwise it is a simple referential group.

If R is binary and one-to-one and if r1 belongs to an exclusive or at-least-one group of E2, a copy of the attribute identifier of E1 is created in E2. It takes the name of E1 and the cardinality of r2. This attribute replaces r1 in groups of E2, thus solving the problem of the is-a constraint. If R has the «subt» stereotype, the new attribute has also the «subt» stereotype.

R is deleted.

Example

Dialog boxes

The first dialog box allows to choose the referenced entity type.

After that, a name must be given to the new attributes.


Transformation of a rel-type into an object type attribute

Transform a rel-type into an object type attribute

Principle

A rel-type is replaced by an object type attribute that references another entity type.

Case 1: Create an object type attribute in E1

Case 2: Create an object type attribute in E1 and E2

Preconditions

R is binary and has neither attributes nor processing units (message 1).

Both roles of R are mono-ET (message 2).

Note

The first case is not possible when:

-

the minimum cardinality of r2 is 1 (this information would be lost after transformation);

-

r1 belongs to groups of E2 (r1 is deleted after transformation; therefore, these groups would lose semantic information).

Messages

1

"This rel-type must be binary and cannot have attributes or processing units."

2

"Both roles of this rel-type must be mono-ET."

Postconditions

First case: an object type attribute Ar2 is created in E1 (cardinality [i1-j1]). Ar2 is object type and references E2. The meta-properties values and notes of R are transferred to Ar2.

Second case: idem + an object type attribute Ar1 is created in E2 (cardinality [i2-j2]). Ar1 is object type and it references E1. The meta-properties values and notes of R are transferred to Ar1. A group containing Ar2 (resp. Ar1) is created in E1 (resp. E2). An inverse constraint is created between the two groups.

First case: r2 is replaced by Ar2 in groups of E1.

Second case: idem + r1 is replaced by Ar1 in groups of E2.

R is deleted.

Additional rule

Once more, two cases must be taken into account:

First case: if j2 equals 1, an identifier containing Ar2 is created in E1. This identifier is primary if E1 has no primary identifier and if i1 = 1, otherwise secondary.

Second case: If j2 (resp. j1) = 1, the group of E1 (resp. E2) associated with the inverse constraint is identifier (primary if E1 (resp. E2) has no primary identifier and if i1 (resp. i2) = 1, otherwise secondary).

Rationale

If j2 = 1, E2 (via R) is an implicit identifier of E1. After transformation, the semantics must be preserved. An identifier containing Ar2 (representing E2) is thus created in E1.

Example

Dialog boxes

The first dialog box allows to choose the entity type that will contain the object attribute.

The second one requires a name for the new object attribute.


Transform an attribute into an entity type

There are three cases:

Transform an attribute into an entity type: instance representation

Transform an attribute into an entity type: value representation

Transform an attribute of a rel-type into an entity type


Transformation of an attribute into an entity type: instance representation

Transform an attribute into an entity type: instance representation

Principle:

Each instance of an attribute Ai of an entity type E1 is represented by an entity E2.

Case 1: Ai is atomic

Case 2: Ai is compound

Preconditions

Ai is a direct attribute (message 1).

Ai or a subset of its components (if compound) can be an identifier of E1, but this identifier cannot include other components (message 2).

Ai or a subset of its components (if compound) cannot be part of groups involved in matching constraints (reference, include, equal, ...), except if Ai (or the subset) is the only component of this group (message 3).

A subset of Ai components cannot belong to a coexistence, exclusive or at-least-one group that contains other components (message 3).

If Ai is a multivalued bag attribute, Ai or a subset of its components cannot belong to an identifier of E1 (message 4).

If Ai is a multivalued attribute, its collection type cannot be unique list, list, unique array or array (message 5).

If Ai is a multivalued compound attribute and if one of its sub-attributes is an identifier of E1, this sub-attribute must be an identifier of Ai too (message 6).

Rationale

Ai cannot be an indirect attribute since the created rel-type must link E2 and its parent.

If Ai belongs to a multi-component identifier, it cannot be replaced by R.E2, since E2 is not identified by Ai. Otherwise, Ai should be replaced by remote attribute Ai from E2 through a path, which is not allowed in DB-MAIN.

If Ai belongs to a group involved in a matching constraint, the transformation would destroy it. However, if Ai (or a subset of its components) is the only component of this group, the latter can be transferred to E2.

If Ai is a multivalued bag attribute and if Ai (or a subset of its components) belongs to an identifier of E1, Ai should become an identifier of E2 after transformation through instance representation. It is impossible because Ai was a bag attribute before transformation (two instances of E2 can have the same value for Ai).

If Ai is a multivalued attribute and if its collection type is unique list, list, unique array or array, after transformation, R should become a list or array of relations. In our representation model, the instances of a rel-type are a set of relations. Therefore, Ai must be converted into a multivalued set attribute before its transformation into an entity type.

If Ai is a multivalued compound attribute and if an attribute of Ai is an identifier of E1, this attribute must also be an identifier of Ai. The below representation of this transformation is wrong because the right side schema is less general than the left side one. According to the left side schema, A21 identifies E1, but an instance of E1 can have more than one instance of A2 having the same value for A21. In the right side schema, an instance of E1 cannot have more than one value for A21 through R.

Messages

1 | "This attribute must be a direct attribute of an entity type."
2 | "This attribute belongs to a multi-component group (identifier or group involved in a matching constraint)."
3 | "A subset of this attribute belongs to a group (identifier, coexistence or group involved in a matching constraint) containing other components."
4 | "A multivalued bag attribute or a subset of its components cannot be an identifier of an entity type."
5 | "The collection type of this multivalued attribute must be 'set'. First convert this attribute!"
6 | "If some components of this attribute identify the parent entity-type, they must identify this attribute too."

Postconditions

An entity type E2, a rel-type R, a role r1 [i1-j1] linking E1 and R and a role r2 [1-N] between E2 and R are created.

Every group of E1 that contains only Ai (or a subset of its components) is transferred to E2.

Ai (or the subset of its components) is replaced by r2 in every other group of E1.

If Ai (or the subset of its components) is a secondary identifier of E2 and if E2 has no primary identifier, Ai (or the subset) becomes a primary identifier (if it contains only mandatory attributes).

Ai is transferred to E2. Its cardinality is set to [1-1]. If Ai is compound, its notes and meta-properties values are transferred to E2.

Additional rule

If Ai is a multivalued set attribute and if it is not an identifier of E1, a hybrid identifier is defined in E2. Two cases are possible.

First case: Ai has an attribute identifier. The hybrid identifier is composed of this attribute and r1.

Second case: Ai has no attribute identifiers. The hybrid identifier is composed of r1 and Ai.

Rationale

If Ai is a multivalued bag attribute, a hybrid identifier cannot be created since an instance of E1 could then be linked to some instances of E2 having the same value for Ai.

Augmented transformation

When Ai is a compound attribute, this transformation is often followed by the disaggregation transformation of Ai. Therefore it is useful to offer a joint transformation that automatically disaggregates Ai.

Example


Transformation of an attribute into an entity type: value representation

Transform an attribute into an entity type: value representation

Principle

Each distinct value of an attribute of an entity type E1 is represented by an entity E2.

Case 1: Ai is atomic

Case 2: Ai is compound

Preconditions

Ai is a direct attribute (message 1).

Ai or a subset of its components (if compound) cannot be part of groups involved in matching constraints (reference, include, equal, ...), except if Ai (or the subset) is the only component of this group (message 2).

A subset of Ai components cannot belong to a coexistence, exclusive or at-least-one group that contains other components (message 3).

Ai cannot have an attribute identifier (message 4).

If Ai is a multivalued attribute, its collection type must be set (message 5).

If Ai is a multivalued compound attribute and if one of its sub-attributes is an identifier of E1, this sub-attribute must be an identifier of Ai too (message 6).

Rationale

Ai cannot be an indirect attribute since the created rel-type must link E2 and its parent.

If Ai belongs to a group involved in a matching constraint, the transformation would destroy it. However, if Ai (or a subset of its components) is the only component of this group, the latter can be transferred to E2.

Note that Ai can belong to a multi-component identifier. Indeed, this situation only applies to single-valued attributes and Ai can be replaced by r2 in this identifier, since Ai is also an identifier of E2.

If Ai is a multivalued bag attribute, the value transformation is impossible because an instance of E1 could then be linked several times to the same instance of E2. And in our representation model, the instances of a rel-type are a set of relations (no redundancy).

If Ai is a multivalued attribute and if its collection type is unique list, list, unique array or array, after transformation, R would become a list or array of relations. In our representation model, the instances of a rel-type are a set of relations. Therefore, Ai must be converted into a multivalued set attribute before its transformation into an entity type.

If Ai has attribute identifiers, we would obtain the following schema after transformation:

E2 is a catalogue of A2. But A21 is not an identifier for all the catalogue. Before transformation, A21 was an identifier for a list of A2 within an instance of E1. These schemas do not bear the same semantics. Now, we transform the first schema through instance representation and obtain the following schema:

Now, we transform A21 into an entity type by value representation.

We transform E2 into a rel-type and we obtain a schema that would be a good representation of the transformation by value of the original schema.

If Ai is a multivalued compound attribute and if an attribute of Ai is an identifier of E1, this attribute must also be an identifier of Ai. The below representation of this transformation is wrong because the right side schema is less general than the left side one. According to the left side schema, A21 identifies E1, but an instance of E1 can have more than one instance of A2 having the same value for A21. In the right side schema, an instance of E1 cannot have more than one value for A21 through R.

Messages

1 | "This attribute must be a direct attribute of an entity type."
2 | "This attribute belongs to a multi-component group involved in a matching constraint."
3 | "A subset of this attribute belongs to a group (coexistence or group involved in a matching constraint) containing other components."
4 | "This attribute cannot have attribute identifiers."
5 | "The collection type of this multivalued attribute must be 'set'. First convert this attribute!"
6 | "If some components of this attribute identify the parent entity-type, they must identify this attribute too."

Postconditions

An entity type E2, a rel-type R, a role r1 [i1-j1] linking E1 and R and a role r2 [1-N] between E2 and R are created.

Every group of E1 that contains only Ai (or a subset of its components) is transferred to E2.

Ai (or the subset of its components) is replaced by r2 in every other group of E1.

If E2 has no primary identifier and if it has a secondary identifier composed of mandatory elements only, the latter is transformed into a primary identifier, otherwise a primary identifier (or secondary if Ai is optional) that contains Ai is created.

If Ai (or the subset of its components) is a secondary identifier of E2 and if E2 has no primary identifier, Ai (or the subset) becomes a primary identifier (if it contains only mandatory attributes).

Ai is transferred to E2. Its cardinality is set to [1-1]. Its notes and meta-properties values are transferred to R.

Additional rule

If Ai or a subset of its components identify E1, the cardinality of r2 is set to [1-1].

Augmented transformation

When Ai is a compound attribute, this transformation is often followed by the disaggregation transformation of Ai. Therefore it is useful to offer a joint transformation that automatically disaggregates Ai.

Example


Transformation of an attribute of a rel-type into an entity type

Transform an attribute of a rel-type into an entity type

Principle

Each distinct value of an attribute Ai of a rel-type R is represented by an entity E.

Case 1: Ai is atomic

Case 2: Ai is compound

Precondition

Ai is a mandatory, single-valued and direct attribute of R (message 1).

Message

1

"This attribute must be a mandatory, single-valued and direct attribute of a rel-type."

Postconditions

If R has no identifier, a primary identifier composed of all its roles (before transformation) is created.

A new entity type E is created. It is linked to R by a new role r [1-N].

Every group of R that contains only Ai (or a subset of its components) is transferred to E.

Ai (or the subset of its components) is replaced by r in every other group of R.

If E2 has no primary identifier and if it has a secondary identifier composed of mandatory elements only, the latter is transformed into a primary identifier, otherwise a primary identifier (or secondary if Ai is optional) that contains Ai is created.

Ai is transferred to E. Its cardinality is set to [1-1]. If Ai is compound, its notes and meta-properties values are transferred to E.

Remove if necessary an implicit identifier that contains all the roles (after transformation) of R.

Rationale

If, before transformation, R has no explicit identifier and if its implicit identifier is the set of all its roles, this identifier must be made explicit because, after transformation, a role is added and the old set of its roles would no longer be an implicit identifier.

Additional rule

If Ai (or a subset of its components) is an identifier of R, the cardinality of r is set to [1-1].

Augmented transformation

When Ai is a compound attribute, this transformation is often followed by the disaggregation transformation of Ai. Therefore it is useful to offer a joint transformation that automatically disaggregates Ai.

Example


Transformation of an object type attribute into a rel-type

Transform an object type attribute into a rel-type

Principle

One or two object type attributes are replaced by a rel-type.

Case 1: Transform an object type attribute into a rel-type

Case 2: Transform two object type attributes involved in an inverse constraint into a rel-type

Preconditions

AE2 is a direct attribute of E1 (message 1).

AE2 is object type (messages 2 and 3).

Second case: if AE2 is involved in an inverse constraint, AE1 (the corresponding attribute) is a direct attribute of E2 (message 4).

Messages

1 | "This attribute must be a direct attribute of an entity type."
2 | "This attribute must be object type."
3 | "This object type attribute must reference an existing entity type."
4 | "If this attribute belongs to a group involved in an inverse constraint, the corresponding attribute must be object type (father of this attribute) and must be a direct attribute of an entity type."

Postconditions

A new rel-type R and two roles (r1 and r2) are created. The cardinality of the new role played by E1 (r1) is [i1-j1].

First case: the cardinality of r2 is [0-N].

Second case: r2 takes the cardinality of AE1 [i2-j2].

The notes of AE2 (and those of AE1 in the second case) are transferred to R.

Transfer of meta-properties values:

First case: the values of meta-properties of AE2 are transferred to R.

Second case: the values of meta-properties that are identical for both AE1 and AE2 are transferred to R.

Second case: the inverse constraint is deleted; mono-component identifiers of E1 (resp. E2) that contain AE2 (resp. AE1) are deleted too if they have no other functions or constraints.

AE2 is replaced by r2 in every group of E1.

Second case: AE1 is replaced by r1 in every group of E2.

AE2 is deleted.

Second case: AE1 is deleted.

Additional rule

Once more, two cases must be taken into account:

First case: if AE2 belongs to a mono-component identifier, the maximum cardinality of r2 is 1. If this identifier has no other functions or constraints, it is deleted.

Second case: if AE2 (resp. AE1) belongs to a mono-component identifier, the maximum cardinality of r2 (resp. r1) is 1. If this identifier has no other functions or constraints, it is deleted.

Rationale

If the maximum cardinality of r2 is 1, E2 is an implicit identifier of E1. The mono-component identifier (AE2) of E1 can be deleted without semantic loss.

Example

Dialog box

The dialog box associated to this transformation requires a name for the new rel-type.


Disaggregation of a compound attribute

Disaggregate a compound attribute

Principle

A compound attribute (Ai) is replaced with its sub-attributes.

Preconditions

Ai is a single-valued compound attribute. Either Ai is mandatory or the cardinality of all Aij (1 £ j £ m) is [1-1] (messages 1 and 2).

If Ai belongs to an identifier, all Aij are single-valued. (and mandatory for a primary identifier) (message 3).

Messages

1 | "This attribute must be mandatory or the cardinality of all its components must be [1-1]."
2 | "This attribute must be single-valued."
3 | "If this attribute belongs to an identifier, all its components must be single-valued (and mandatory for a primary identifier)."

Postconditions

If the compound attribute is optional and has more than one sub-attribute, a coexistence group composed of all its sub-attributes is created.

Ai is replaced by Aij (1 £ j £ m) in every group of E, except for exclusive and/or at-least-one groups in which Ai is replaced by the coexistence group created above.

The father of Ai becomes the father of Ai (1 £ j £ m). The new cardinality of each Aij is the product of the cardinalities of Ai and Aij.

If Ai belongs to a coexistence group and does not belong to any exclusive and/or at-least-one group, the first postcondition is not applied.

Ai is deleted.

Rationale

If Ai belongs to a coexistence group and does not belong to any exclusive and/or at-least-one group, the first postcondition is not applied. The coexistence constraint to which Ai belongs means that there is a coexistence constraint between Ai (i.e. all its components) and every other component of the group. The first postcondition would therefore create a useless constraint.

Example

Dialog box

The dialog box associated to this transformation has the following features:

Prefix | : | to choose a common prefix (can be the empty string) for the sub-attributes of the current attribute;
Ok | : | to execute the transformation;
Cancel | : | to cancel the transformation.


Transformation of a multivalued attribute into a single-valued attribute

Transform a multivalued attribute into a single-valued attribute

Principle

A multivalued attribute (Ai) is replaced by a single-valued attribute Ais.

Preconditions

Ai is a multivalued (set, bag, unique list, list, unique array, array) atomic attribute (message 1).

The type of Ai is char or varchar (message 2).

Ai does not belong to any group (message 3).

Warning: If the collection type of Ai is set, bag, unique list, unique array or array, original semantics is not preserved (message 4).

Rationale

If Ai is a set, bag, unique list, unique array or array attribute, original semantics is altered after transformation. The table below shows the lost and additional constraints corresponding to each structure.

 | Unique | Order | Gap
Set | - | + |
Bag |  | + |
Unique List | - |  |
List |  |  |
Unique Array | - |  | -
Array |  |  | -

Transforming a list attribute does not alter semantics since its values are ordered, non unique and without gaps.

Messages

1 | "This attribute must be multivalued and atomic."
2 | "This attribute must be char or varchar."
3 | "This attribute cannot belong to any group."
4 | "Transform the multivalued attribute Ai into a single-valued attribute.
 | Warning: This transformation is not semantics-preserving !"

Postconditions

Ai is renamed Ais.

The cardinality of Ais is [i2-1] (if i1 = 0 then i2 = 0, otherwise i2 = 1).

The length of Ais is j1 times the length of Ai.

Example


Transformation of a single-valued attribute into a multivalued attribute

Transform a single-valued attribute into a multivalued attribute

Principle

A single-valued attribute (Ais) is replaced by a multivalued attribute (Ai).

Preconditions

Ais is a single-valued atomic attribute (message 1).

The type of Ais is char or varchar (message 2).

Ais does not belong to any group (message 3).

Warning: If Ai is transformed into a set, bag, unique list, unique array or array attribute, original semantics is not preserved (message 4).

Rationale

If Ai is transformed into a set, bag, unique list, unique array or array attribute, original semantics is altered after transformation. The table below shows the lost and additional constraints corresponding to each structure.

 | Unique | Order | Gap
Set | + | - |
Bag |  | - |
Unique List | + |  |
List |  |  |
Unique Array | + |  | +
Array |  |  | +

Transforming Ai into a list attribute does not alter semantics since list values are ordered, non unique and without gaps.

Messages

1 | "This attribute must be single-valued and atomic."
2 | "This attribute must be char or varchar."
3 | "This attribute cannot belong to any group."
4 | "Transform the single-valued attribute Ais into a multivalued attribute.
 | Warning: This transformation is not semantics-preserving !"

Postconditions

Ais is renamed Ai (or keeps its name if it does not end with 's')

If the length of Ais is N, the length of Ai is any positive integer. In other cases, the length of Ai is an integer factor of the length of Ais.

If the length of Ais is N, i2 = i1 and j2 = N. Otherwise, i2 = i1 and j2 = the length of Ais divided by the length of Ai.

Example

Dialog box

The dialog box requires the length of the multivalued attribute. This value must be an integer factor of the original length.


Transformation of a multivalued attribute into a list of single-valued attributes

Transform a multivalued attribute into a list of single-valued attributes

Principle

A multivalued attribute (Ak) is replaced by a list of similar single-valued attributes.

Case 1: Ak is atomic

Case 2: Ak is compound

Preconditions

Ak is a multivalued attribute. (message 1).

The maximum cardinality of Ak cannot be N (message 2).

If Ak belongs to an identifier or a reference group, this group must be mono-component (message 3).

Warning: if the collection type of Ak is set, bag, unique list, list or unique array, original semantics is not preserved (message 4).

Rationale

If the cardinality of Ak is [i1-N], it is not possible to replace Ak by N single-valued attributes because N stands for 'any positive integer'.

If Ak is a set, bag, unique list, list or unique array attribute, original semantics is altered after transformation. The table below shows the lost and additional constraints corresponding to each structure.

 | Unique | Order | Gap
Set | - | + | +
Bag |  | + | +
Unique List | - |  | +
List |  |  | +
Unique Array | - |  |
Array |  |  |

Transforming an array attribute does not alter semantics since its values are ordered, non unique and gaps are allowed.

Messages

1 | "This attribute must be multivalued."
2 | "The maximum cardinality of this attribute cannot be N."
3 | "This attribute can only belong to mono-component identifiers and reference groups."
4 | "Transform the multivalued attribute Aik into a list of single-valued attributes.
 | Warning: This transformation is not semantics-preserving !"

Postconditions

j1 attributes are created. They take all properties of Ak (type, length, descriptions, values of meta-properties, notes, ...). Their maximum cardinality is 1. The first i1 attributes are mandatory, the others are optional.

Ak is replaced by Ak1 in all groups. j1-1 similar groups in which Ak2, ..., Akj1 replace Ak are created.

Ak is deleted.

Example

Dialog box

The dialog box associated to this transformation has the following features:

Prefix | : | to choose a common prefix for the new single-valued attributes;
Ok | : | to execute the transformation;
Cancel | : | to cancel the transformation.


Conversion of a multivalued attribute

Principle

The collection type of a multivalued attribute (Ak) is converted into another collection type with or without semantic loss.

Case 1: conversion with semantic loss

Case 2: conversion of a non-set attribute into a set attribute (without semantic loss)

Case 3: conversion of a set attribute into a non-set attribute (without semantic loss)

Precondition

Ai is a multivalued attribute. (message 1).

Rationale

This is the most general precondition. But Ai cannot be converted into every collection type. There are additional conditions depending on the type of conversion. The table below shows possible conversions.

Conversion | Semantics-preserving | Conditions
Set -> Bag (with loss) | - unicity |
Set -> Bag (without loss) |  | Ai is compound, value is id
Set -> U-list (with loss) | + order |
Set -> U-list (without loss) |  | Ai is compound, value and index are id
Set -> List (with loss) | - unicity, + order |
Set -> List (without loss) |  | Ai is compound, index is id
Set -> U-array (with loss) | + order, + gap |
Set -> U-array (without loss) |  | Ai is compound, value and index are id
Set -> Array (with loss) | - unicity, + order, + gap |
Set -> Array (without loss) |  | Ai is compound, index is id
Bag -> Set (without loss) |  |
Bag -> List (with loss) | + order |
Bag -> Array (with loss) | + order, + gap |
U-list -> Set (with loss) | - order |
U-list -> Set (without loss) |  |
U-list -> Bag (with loss) | - unicity, - order |
U-list -> List (with loss) | - unicity |
U-list -> U-array (with loss) | + gap |
U-list -> Array (with loss) | - unicity, + gap |
List -> Set (without loss) |  |
List -> Bag (with loss) | - order |
List -> Array (with loss) | + gap |
U-array -> Set (with loss) | - order, - gap |
U-array -> Set (without loss) |  |
U-array -> Bag (with loss) | - unicity, - order, - gap |
U-array -> U-list (with loss) | - gap |
U-array -> List (with loss) | - unicity, - gap |
U-array -> Array (with loss) | - unicity |
Array -> Set (without loss) |  |
Array -> Bag (with loss) | - order, - gap |
Array -> List (with loss) | - gap |

If the collection type is bag, list or array, it cannot be converted into set, u-list or u-array with loss because the unicity property would be added. Some redundant values stored in a bag, list or array attribute could be lost in a set, u-list or u-array attribute.

If the collection type is non-set, it cannot be converted into a non-set collection type without loss.

Message

1

"This attribute must be multivalued."

Postconditions

Case 1: conversion with semantic loss.

The collection of Ai becomes ct2 without other transformations.

Case 2: conversion of a non-set attribute into a set attribute (without semantic loss).

A compound attribute that takes the name and properties of Ai is created. If old Ai is a bag, list or array attribute and if i1 > 1, i2 is set to 1.

An atomic attribute (cardinality [1-1]) is added to new Ai. If ct1 is bag, this attribute is given the numeric type and is named multiplicity. If ct1 is list or u-list, this attribute is given the sequence type and is named sequence. If ct1 is array or u-array, this attribute is given the index type and is named index.

Old Ai becomes an attribute of new Ai. Its name is value and its cardinality is [1-1]. Identifiers of value are transferred to new Ai.

If the collection type of old Ai is not bag, an identifier (primary if Ai has no primary identifier, secondary otherwise) containing index (or sequence) is added to Ai. If the collection type of old Ai is bag, u-list or u-array, an identifier (primary if Ai has no primary identifier, secondary otherwise) containing value is added to Ai.

The collection type of Ai becomes set.

Case 3: conversion of a set attribute into a non-set attribute (without semantic loss).

The index (multiplicity or sequence) attribute is deleted.

If Ai has only one compound attribute, all groups, attributes, values of meta-properties and notes of this compound attribute are transferred to Ai and the compound attribute is deleted.

If Ai has only one atomic attribute, Ai becomes an atomic attribute and takes the type, length, decim and values of meta-properties of this attribute. The attribute of Ai is deleted.

Identifiers of Ai that contain all its attributes are deleted.

The collection type of Ai becomes ct2.

Examples

Dialog box

The dialog box associated to this transformation has the following features:

The displayed list allows to choose the kind of conversion that must be performed;
Ok | : | to execute the transformation;
Cancel | : | to cancel the transformation.


Materialization of the user-defined domain of an attribute

Principle

Replace the type of a user-defined attribute with its domain.

Case 1: materialize an atomic domain

Case 2: materialize a compound domain

Precondition

Ai is a user-defined attribute (message 1).

Message

1

"This attribute must be user-defined."

Postconditions

If the domain DOMk of Ai is atomic, Ai is the same type, length and decim as DOMk.

If the domain DOMk of Ai is compound, Ai becomes a compound attribute and its sub-attributes (DOMk1, ..., DOMkm) are copies of the sub-attributes of DOMk.

Example


Transformation of a multi-ET role into rel-types

Transform a multi-ET role into rel-types

Principle

A rel-type containing a multi-ET role is splitted into several similar rel-types, one for each entity type participating in this role.

Precondition

r2 is a multi-ET role (message 1).

Message

1

"This role must be multi-ET."

Postconditions

For each entity types Ei (1 £ i £ n) playing the role r2, a copy Ri of R is created. The new rel-types have:

the same prefix,

the attributes of R

the processing units of R

the values of meta-properties of R

the notes of R

the roles of R (except r2) with the same name, values of meta-properties, notes and participating entity types. The cardinality of these roles is set to [0-j1]

the role r2 with the same name, cardinality, values of meta-properties and notes. This role is now mono-ET and links E to Ei.

the groups of R in which attributes and roles are replaced by the new attributes and roles of Ri.

Roles of R are replaced by the new roles of Ri in every group that contained roles of R before transformation (except for identifiers containing r2).

Identifiers containing r2 are replaced by as many secondary identifiers as there are Ei entity types. They contain the same components but the new roles played by Ei replace r2. Identifiers containing r2 are deleted

For each entity types that plays a role (except r2) in R, if the cardinality of this role is:

[0-1]: an exclusive group composed of the roles played by Ei in Ri is created;

[1-1]: an exactly-one group composed of the roles played by Ei in Ri is created;

[1-N]: an at-least-one group composed of the roles played by Ei in Ri is created.

R is deleted

Example

Dialog box

The dialog box associated to this transformation has the following features:

Prefix | : | To choose a common prefix for the new rel-types;
OK | : | to execute the transformation;
Cancel | : | to cancel the transformation.


Transformation of a group (foreign key) into a rel-type

Transform a group (foreign key) into a rel-type

Principle

A group of attributes involved in a matching constraint (reference) is replaced by a rel-type.

Preconditions

The group is involved in a referential constraint (message 1). Its attributes are reference attributes.

- | {id21, ..., id2n} is an identifier of E2 different from {id11, ..., id1n} (message 2).
- | Both groups belong to entity types (message 3).
- | Both groups are the same length and have the same number of direct attributes (messages 4, 5 and 8).
- | the reference attributes have the same cardinality (message 6).
- | the attributes of both groups are not object type (message 10).
- | If the reference attributes are optional, the group has also the coexistence property (message 9).
- | If the attributes are multivalued, their collection type is set (message 7).

The reference attributes do not belong to a group involved in another referential constraint (message 11).

If the reference attributes of this group appear in other groups, they must appear together (message 12).

Messages

1 | "This group must be the origin of a referential constraint."
2 | "The referenced group must be an identifier different from this group."
3 | "The groups involved in this constraint must belong to an entity type."
4 | "The components of the groups involved in this constraint must be direct attributes of an entity type."
5 | "The groups involved in this constraint must have the same number of components."
6 | "The attributes of this group must have the same cardinality ([0-1] or [1-1])."
7 | "The collection type of these attributes must be the set type."
8 | "The total length of the groups involved in this constraint must be equal."
9 | "If the components of this group are optional, the group must be also a coexistence group."
10 | "The attributes of the groups involved in this constraint cannot be object type."
11 | "The components of this group cannot appear in other referential constraints."
12 | "The components of this group must appear together in other groups."

Postconditions

A new rel-type R is created. Two roles (r1 and r2) are created to link R to E1 and E2.

the cardinality of r2 is that of the reference group (the minimum cardinality of r2 is more than 0 if an equality constraint can be asserted; the maximum cardinality of r2 is 1 if {id11, ..., id1n} is an identifier of E1).

the cardinality of r1 is that of the reference attributes id1i (1 £ i £ n).

the values of meta-properties and notes of the referential group are transferred to R.

Reference attributes are replaced by r2 in every group of E1. Warning: if an identifier of E1 contains only r2, it is an implicit identifier (thus it will be destroyed).

id11, ..., id1n are deleted.

If the transformed group has the exclusive, at-least-one, user-defined or access key property, its other properties (identifier or coexistence) are removed and the referential constraint is destroyed. Otherwise the group is deleted.

Example


Aggregation of a list of attributes

Aggregate a list of attributes

Principle

Aggregate a list of attributes (group G) in order to form a compound attribute.

Precondition

All components of G (at least one) are attributes and have the same father (messages 1 and 2).

Messages

1 | "This group must have at least one component."
2 | "The components of this group must be attributes and have the same parent."

Postconditions

A new compound attribute AC is created. Its cardinality is [1-1].

AC becomes the father of Ai1, ..., Am.

{Ai, ..., An} are replaced by AC in every group of E1 (except for exclusive and/or at-least-one groups). If one of these groups is submitted to the coexistence constraint, the cardinality of AC is set to [0-1] and the minimum cardinality of Aj (i £ j £ m) is set to 1. This coexistence group is replaced by AC in every group of E1 to which it belongs. This coexistence group is destroyed if its only property is coexistence and if it contains only AC.

Example


Transformation of a group of attributes into a multivalued attribute

Transform a group of attributes into a multivalued attribute

Principle

A group composed of similar attributes is replaced by a multivalued attribute.

Preconditions

The components of the group are single-valued attributes (message 1).

These attributes have the same father, the same number of decimal digits (if atomic attributes) and the same number of sub-attributes (if compound attributes). They are the same type and length (message 2).

This group has no specific function (id, ref, ...) and is not member of other groups. No subset of its components can belong to groups, except if every one of these components is a single-component identifier or reference constraint referencing the same identifier (message 3, 4, 5 et 6).

Warning: if the list of attributes is transformed into a set, bag, unique list, list or unique array multivalued attribute, original semantics is not preserved.

Rationale

If Ak1, ..., Akn are transformed into a set, bag, unique list, list or unique array attribute, original semantics is altered. The table below shows the lost and additional constraints corresponding to each structure.

 | Unique | Order | Gap
Set | + | - | -
Bag |  | - | -
Unique List | + |  | -
List |  |  | -
Unique Array | + |  |
Array |  |  |

The transformation into an array attribute does not alter semantics since values are ordered, non unique and gaps are allowed.

Messages

1 | "The components of this group must be single-valued attributes"
2 | "The components of this group must have the same parent and number of decimal digits. They must be the same type and length."
3 | "All the components of this group must belong to the same multi-component groups. These groups cannot have any function."
4 | "If every component of this group is the only member of a reference group, these groups must reference the same identifier."
5 | "If a component of this group belongs to a mono-component reference group, the other components must belong to similar groups."
6 | "If a component of this group is a mono-component identifier, the other components must belong to similar groups."

Postconditions

A new multivalued compound attribute (Ak) is created. Its collection type is array. The values of meta-properties that are identical for each Aki (1 i j1) are transferred to Ak. The notes of each Aki (1 i j1) are transferred to Ak. The cardinality of Ak is [i1-j1] where j1 is the number of attributes in the group and i1 is the number of mandatory attributes in the group. A mandatory numeric attribute called Index is created in Ak. The suffix of each attribute (1,…,j1) is stored in the Value constraint meta-property of Index. If Ak1, …, Akj1 are atomic, an attribute called Value is created in Ak. This attribute takes the properties of Ak1 (type, length, decim,…). The cardinality of Value is [0-1] if i1<j1 and [1-1] if i1=j1. If Ak1, …, Akj1 are compound, the sub-attributes of Ak1 are transferred to Ak.

Ak1 is replaced by the new attribute Ak in all groups.

The attributes ( Ak) composing the group are deleted.

The group is deleted.

Example


Remove prefix of the attributes of an entity type, a rel-type or a compound attribute

Remove the prefix of every attribute of an entity type, a rel-type or a compound attribute

Principle

Detect the largest common prefix of the attributes (if at least two attributes) of the selected object and remove it. This is equivalent to the Change prefix transformation with no new prefix.

Postcondition

The common prefix of all attributes (first level) of a parent (entity type, rel-type or compound attribute) are removed.

Note 1: if one attribute is the prefix, this transformation will make this attribute have no name.

Note 2: if the parent has got only one attribute, it is considered to have no prefix.

Example

Dialog box

The dialog box associated to this transformation has the following features:

Ok | : | to execute the transformation;
Cancel | : | to cancel the transformation.


Change prefix of the attributes of an entity type, a rel-type or a compound attribute

Change the prefix of every attribute of an entity type, a rel-type or a compound attribute

Principle

Detect the largest common prefix of the attributes of the selected object and change it.

Case 1: change the prefix of all attributes of an entity type

Case 2: change the prefix of all attributes of a rel-type

Case 3: change the prefix of all attributes of a compound attribute

Postcondition

The prefix of all attributes (first level) of a parent (entity type, rel-type or compound attribute) are replaced by a new one. If there is no common prefix, the new one is simply added.

Example

Dialog box

The dialog box associated to this transformation has the following features:

Prefix | : | to choose the new prefix for all attributes of the current object;
Ok | : | to execute the transformation;
Cancel | : | to cancel the transformation.


Customization of transformations through pre- and post-processing

Customization of elementary transformations through pre- and post-processing

The execution of specific Voyager 2 functions before and after each transformation allows to customize elementary transformations.

These functions are contained in the provided Voyager 2 file TRANSFO.V2. The name and the parameters of these functions cannot be changed. Only the body (between {}) can be modified.

When TRANSFO.V2 is modified, it must be compiled. The compiled file TRANSFO.OXO must be stored in the same directory as the application file DB_MAIN.EXE.


Global transformations

The global transformation assistant allows to perform selected actions on selected objects in order to solve structural problems. For each outstanding class of constructs (the problem), this assistant suggests one or several transformations that can replace them with equivalent constructs (the solution) or simply mark or unmark the selected constructs. This assistant offers other additional global functions.

In the descriptions below, the standard design processes in which the explained operation can be most useful are given between brackets according to the following codes:

CN: | conceptual normalization
RE: | reverse engineering
LD: | logical design (DBMS-independent)
RLD: | relational logical design
FLD: | standard file logical design (e.g. Cobol)
CLD: | Codasyl logical design
OP: | optimization
PD: | physical design

Actions

Entity types | Problems related to entity types:
Rel. entity types
-> Rel-types | to transform into rel-types those entity types that appear to represent rel-types (CN);
-> mark/unmark | to mark/unmark rel. entity types;
Att. entity types
-> Attributes | to transform into attributes those entity types that appear to represent attributes (CN);
-> mark/unmark | to mark/unmark att. entity types;
Missing id.
-> Add a technical id | to add a technical identifier to those entity types that have no explicit one (RLD);
-> mark/unmark | to mark/unmark these entity-types.
Rel-types | Problems related to relationship types:
With attributes
-> Entity types | to transform into entity types those rel-types that have attributes (LD);
-> mark/unmark | to mark/unmark these rel-types;
Complex
-> Entity types | to transform into entity types N-ary rel-types and rel-types containing attributes (LD);
-> mark/unmark | to mark/unmark complex rel-types;
Binary 1-1
-> Is-a | to transform binary one-to-one rel-types into is-a relations (CN);
-> mark/unmark | to mark/unmark binary one-to-one rel-types;
Binary 1-N
-> Referential attributes | to transform binary one-to-many rel-types into referential attributes (RLD,FLD);
-> mark/unmark | to mark/unmark binary one-to-many rel-types;
Binary N-N
-> Entity types | to transform many-to-many rel-types into entity types (LD);
-> mark/unmark | to mark/unmark binary many-to-many rel-types;
Binary w/o att.
-> Object attributes | to transform into object type attributes those binary rel-types that have no attributes (LD);
-> mark/unmark | to mark/unmark these rel-types;
Cyclic
-> Entity types | to transform cyclic rel-types into entity types (CLD);
-> mark/unmark | to marks/unmark cyclic rel-types;
Cyclic 1-N
-> Referential attributes | to transform cyclic one-to-many rel-types into referential attributes (CLD);
-> mark/unmark | to mark/unmark cyclic one-to-many rel-types;
Multi-ET roles
-> Split rel-types | to split multi-ET roles into rel-types (LD);
 | if a rel-type has several multi-ET roles, this global transformation must be repeated several times to remove all multi-ET roles;
-> mark/unmark | to mark/unmark multi-ET roles.
Is-a | Problems related to is-a relations:
All
-> Rel-types | to transform is-a relations into one-to-one relationship types (LD);
-> mark/unmark | to mark/unmark is-a relations.
Attributes | Problems related to attributes:
Compound
-> Disaggregation | to replace compound attributes with their components (RLD);
-> Entity types | to transform compound attributes into entity types (CN,LD);
-> mark/unmark | to mark/unmark compound attributes;
Multivalued
-> Entity types | to transform multivalued attributes into entity types (using instance representation) (LD);
-> mark/unmark | to mark/unmark multivalued attributes;
Object
-> Rel-types | to transform object type attributes into rel-types (RE);
-> mark/unmark | to mark/unmark object type attributes;
User-defined
-> Materialize | to replace user-defined attributes with their definition (LD);
-> mark/unmark | to mark/unmark user-defined attributes;
Comp. att, 1 comp.
-> Disaggregation | to disaggregate those compound attributes that have only one component (LD);
-> mark/unmark | to mark/unmark these compound attributes;
Single comp. att, FK
-> Disaggregation | to disaggregate single-valued compound attributes that have component(s) associated with a FK (RE);
-> Entity type | to transform into entity types those single-valued compound attributes that have component(s) associated with a FK (RE);
-> mark/unmark | to mark/unmark these single-valued compound attributes;
Multi. comp. att, FK
-> Entity type | to transform into entity types those multivalued compound attributes that have component(s) associated with a FK (RE);
-> mark/unmark | to mark/unmark these multivalued compound attributes.
Groups | Problems related to groups:
Referential
-> Rel-types | to transform reference groups into one-to-many rel-types (RE);
-> mark/unmark | to mark/unmark reference groups;
Id. & ref. w/o AK
-> Make access key | to associate access keys with identifier and reference groups (PD);
-> mark/unmark | to mark/unmark referential and identifier groups that are not associated with an access key;
Id. >1 comp.
-> Add a technical id | to replace with a technical id those primary ids, belonging to entity types, that are made up of more than 1 component, and which can raise a problem during some further transformation (the entity type plays a role in a complex rel-type, is the target of a binary rel-type or is a super-type of another entity type which plays one of these roles) (OP,PD);
-> mark/unmark | to mark/unmark these identifiers;
Id. >2 comp.
-> Add a technical id | to replace with a technical id those primary ids, belonging to entity types, that are made up of more than 1 component, that are made up of more than 2 components, and which can raise a problem during some further transformation (see Id.>1 comp. above for more details) (OP,PD);
-> mark/unmark | to mark/unmark these identifiers;
Id. >3 comp.
-> Add a technical id | to replace with a technical id those primary ids, belonging to entity types, that are made up of more than 1 component, that are made up of more than 3 components, and which can raise a problem during some further transformation (see Id.>1 comp. above for more details) (OP,PD);
-> mark/unmark | to mark/unmark these identifiers;
Access keys
-> Remove | to remove access keys (RE);
-> mark/unmark | to mark/unmark access key groups;
Multi-att. identifiers
-> Aggregate | to transform multi-attribute identifiers into compound attributes (FLD);
-> mark/unmark | to mark/unmark multi-attribute identifiers;
Multi-att. access keys
-> Aggregate | to transform multi-attribute access keys into compound attributes (FLD);
-> mark/unmark | to mark/unmark multi-attribute access keys;
Prefix access keys
-> Remove | to remove prefix access keys (OP, PD);
-> mark/unmark | to mark/unmark prefix access keys;
Coexistence
-> Aggregate | to transform coexistence groups into optional compound attributes (CN);
-> mark/unmark | to mark/unmark coexistence groups;
Names
-> Rename | to rename groups with unique (in the schema scope) standardized names (PD).
Miscellaneous | Problems related to various objects:
Prefixed attributes
-> Remove prefix | to remove the common prefix of all the attributes (if at least two) of entity types, rel-types and compound attributes (RE);
Tech. descriptions
-> Remove | to remove technical descriptions (RE);
-> mark/unmark | to mark/unmark objects that have a technical description;
Collections
-> Remove | to remove collections (RE);
-> mark/unmark | to mark/unmark collections.
Generate | To generate executable DDL code:
Standard SQL | standard SQL-2 program;
Access | Access SQL program;
Interbase | Interbase SQL program;
MySQL | MySQL SQL program;
PostgreSQL | PostgreSQL SQL program;
Academic SQL | simplified SQL program;
COBOL | COBOL ENVIRONMENT and DATA SECTION (file and record structures);
CODASYL | CODASYL or IDS/II program (schema and sub-schemas);
XML | XML DTD file.
Name processing | to process the names of selected parts of the schema.
Comment | to add a free text comment to a script in order to improve its readability. This comment is not executed.

Scripts

A script is a sequence of operations selected among those described above.

Add | to add the selected action at the end of the current script;
Insert | to insert the selected action before the operation that is selected in the script;
Remove | to remove the selected operation from the script;
Edit | to edit the Name processing operation that is selected in the script;
Clear | to clear the script window;
Pre-defined | to load a pre-defined script; the following scripts are available:
Binary | no is-a; to transform complex rel-types;
Bachman | Binary + one-to-many, non-cyclic rel-types only;
Flat binary | Binary + single-valued, atomic attributes only;
Flat Bachman | Bachman + single-valued, atomic attributes only;
Relational rev. eng. | to rebuild a conceptual schema from a (simple) relational logical schema;
COBOL rev. eng. | to rebuild a conceptual schema from a (simple) COBOL logical schema;
Pseudo-relational | in most cases, this script can transform a conceptual schema into a physical relational schema;
Logical pseudo-relational | in most cases, this script can transform a conceptual schema into a logical relational schema;
Physical pseudo-relational | in most cases, this script can transform a logical schema into a physical relational schema;
Pseudo-Cobol | in most cases, this script can transform the current schema into a logical Cobol schema;
Pseudo-IDS/II | in most cases, this script can transform the current schema into a logical Codasyl schema.
Load | to load a previously saved script (file *.scr);
Save | to save the current script (file *.scr);
Copy | to copy the current script to the clipboard;
Confirmation | if checked, the assistant requests confirmation for each transformation;
Ok | if the script window is empty, the selected action is executed;
 | if the script window contains operations, they are executed;
Cancel | to close the assistant without taking any action;
Help | to get help information on the purpose and use of the global transformation assistant.


Transformation scripts

Advanced global transformations

An advanced global transformation allows to automate the application of some transformations to a schema by means of a script. Such a script is made up of primitive transformations (the scope of which can be specified) and control structures (scope restrictions and loops). Advanced global transformation scripts can be gathered into a library so that they can be reused afterwards when defining new ones.

Transformations

A transformation is designed to perform a given action on a set of objects. Each transformation is associated with a default set. This set can be restricted to a subset by means of a predicative rule chosen among the search rules of the Schema Analysis Assistant. For instance, the RT_into_ET transformation is designed to transform all rel-types of a schema into entity types. But this transformation may be refined to transform complex rel-types only:

 | RT_into_ET(ATT_per_RT(1 N) OR ROLE_per_RT(3 N) OR PROCUNIT_per_RT(1 N))
All available transformations and their default scope are listed below:
ET_into_RT, default scope: all entity types.
 | To transform into rel-types all entity types that comply with the preconditions of the corresponding elementary transformation.
ET_into_ATT, default scope: all entity types.
 | To transform into attributes all entity types that comply with the preconditions of the corresponding elementary transformation.
ADD_TECH_ID, default scope: all entity types.
 | To add a technical identifier to all entity types. This transformation should never be used without refining the scope (see the corresponding elementary transformation details).
SMART_ADD_TECH_ID, default scope: all entity types.
 | To add a technical identifier to all entity types that have no explicit one but should so that all rel-types could be transformed into referential constraints.
ISA_into_RT, default scope: all is-a relations.
 | To transform all is-a relations into binary one-to-one rel-types (see the corresponding elementary transformation details).
RT_into_ET, default scope: all rel-types.
 | To transform all rel-types into entity types. This transformation should never be used without refining the scope (see the corresponding elementary transformation details).
RT_into_ISA, default scope: all rel-types.
 | To transform into is-a relations all binary one-to-one rel-types that comply with the preconditions of the corresponding elementary transformation. Some is-a relations may remain after this global transformation. In this case, they can possibly be transformed via the elementary transformation).
RT_into_REF, default scope: all rel-types.
 | To transform all rel-types into referential attribute(s).
RT_into_OBJATT, default scope: all rel-types.
 | To transform all rel-types into object type attribute(s).
REF_into_RT, default scope: all referential attributes.
 | To transform all referential attributes into rel-types.
ATT_into_ET_VAL, default scope: all attributes.
 | To transform all attributes into entity types using the value representation strategy. This transformation should never be used without refining the scope.
ATT_into_ET_INST, default scope: all attributes.
 | To transform all attributes into entity types using the instance representation strategy. This transformation should never be used without refining the scope.
OBJATT_into_RT, default scope: all object type attributes.
 | To transform all object type attributes into rel-types.
DISAGGREGATE, default scope: all compound attributes.
 | To disaggregate all compound attributes.
INSTANCIATE, default scope: all multivalued atomic attributes.
 | To transform all multivalued atomic attributes into a list of single-valued attributes.
MATERIALIZE, default scope: all user-defined attributes.
 | To replace all user-defined attributes with their definition.
REMOVE_PREFIX_of_ATT, default scope: all entity types, rel-types and compound attributes.
 | To remove the common prefix of all the attributes (if at least two) of the objects in the scope.
SPLIT_MULTIET_ROLE, default scope: all roles.
 | To split all multi-ET roles into rel-types.
AGGREGATE, default scope: all groups.
 | To transform all multi-attribute groups into compound attributes. This transformation should never be used without refining the scope.
GROUP_into_KEY, default scope: all groups.
 | To associate an access key to all groups.
RENAME_GROUP, default scope: all groups.
 | To give a new meaningful name to each group. The generated names are unique within the schema scope. Note that old names are lost permanently (non reversible transformation).
REMOVE_KEY, default scope: all access keys.
 | To remove all access keys.
REMOVE_PREFIX_KEY, default scope: all access keys.
 | To remove all access keys that are a prefix of another one.
REMOVE_TECH_DESC, default scope: all objects of the current schema, except for the schema itself.
 | To remove the technical description of all objects of the current schema.
REMOVE, default scope: NONE; the definition of a scope is mandatory.
 | To remove all the objects that are in the specified scope. The deleted objects are lost permanently.
 | This transformation is very special, it does not exactly conform to the definition of a transformation since there is no default scope.
NAME_PROCESSING, default scope : NONE; the definition of a scope is mandatory.
 | To process object names and short names within the defined scope. See the name processing help page for more information on the possible name transformations.
 | This transformation has two parameters (in the script). The second one gives the rule defining the set of objects to process. The first one gives the patterns as described below:
 | 'L' stands for 'conversion of upper case letters to lower case letters';
 | 'U' stands for 'conversion of lower case letters to upper case letters';
 | 'C' stands for 'capitalization';
 | 'A' stands for 'accents removal';
 | 'S' stands for 'shortening' and is followed by the maximum size allowed for new names;
 | 'P' stands for 'patterns' and is followed by the list of patterns that must comply with the following syntax:
 | search_pattern_1;replace_pattern_1;...;search_pattern_n;replace_pattern_n;
 | Semi-colons (;), quotes (“) and backslashes (\) used in patterns must be escaped
 | (prefixed) by a backslach (\).
MARK, default scope: NONE; the definition of a scope is mandatory.
 | To mark all the objects that are in the specified scope.
 | This transformation is very special, it does not exactly conform to the definition of a transformation since there is no default scope and no real transformation.
UNMARK, default scope: NONE; the definition of a scope is mandatory.
 | To unmark all the marked objects that are in the specified scope.
 | This transformation is very special, it does not exactly conform to the definition of a transformation since there is no default scope and no real transformation.
EXTERN, default scope: NONE; the definition of a scope is mandatory.
 | To call an external Voyager 2 function (i.e. a user defined function). See Extern Advanced Global Transformation for more information on the subject.

Control structures

ON (<rule>)...ENDON

This structure allows to reduce the scope of a set of transformations. The rule is evaluated and the set of objects found becomes the current scope for all subsequent transformations until the ENDON keyword.

 | During execution, some transformations may destroy objects included in the scope. In that case, these objects cannot be manipulated any more by the following transformations. Some transformations may as well create objects that comply with the ON clause. In that case, these objects are not added to the scope. To address this question, the ON...ENDON structure can be inserted in a LOOP...ENDLOOP structure.
 | Note that ON...ENDON structures cannot overlap, i.e. an ON...ENDON structure cannot be inserted in another ON...ENDON structure.
LOOP...ENDLOOP
 | This structure allows to repeat a sequence of actions until a fixpoint is reached. The LOOP keyword is only a label in the script, i.e. when encountered, no action is performed. All the transformations that follow it are executed until the ENDLOOP keyword is reached. Then, if the schema has effectively been modified, the sequence is performed once more. The process goes on like that until a fixpoint is reached (i.e. the schema has not been modified during the last loop).
 | Note that a LOOP...ENDLOOP structure can be inserted in another one.

How to define a script ?

All predefined transformations are listed in the Primitive transformations list; all control structures are listed in the Control structures list and all scripts of the current library are listed in the Library list. To define a script, the following procedure must be followed.

1. | Choose a transformation, a control structure (or just a keyword of one of them), a library entry, or check the Comment box. Then use the Add button (or double-click on the predicate) to add the chosen item at the end of the script or select a line in the script and use the insert button to add the chosen item before the selected line.
1. | When the Global transformation parameter edit dialog box appears (not for comments and some control sturcture keywords), write a rule (optional, but no more than one) in the way described in the Schema analysis assistant section.
 | If the Comment box was checked, type a free text comment in the text field and press OK to validate.
1. | Repeat 1 and 2 until the script is finished.
1. | To make corrections, use the Remove button to remove the selected item from the script and the Edit button (or a double-click on an item of the script) to open again the Global transformation parameter edit dialog box and make all requested changes.
To erase the current script, press the Clear button.
To get the list of built-in scripts, press the Predefined button. These scripts can be executed and modified.
To use a previously saved script, press the Load button.
To save the current script, press the Save button.
To copy the current script to the clipboard, press the Copy button.
To open the Transformation library dialog box, press the Edit library button.

How to execute a script ?

To perform the transformations defined in the script, press the Ok button. After execution, the window is closed but the script is kept so that it can be reused later during the same DB-MAIN session. During execution (which can be endless if the script is not well written) the Abort button allows to stop execution.

To close the window without keeping nor executing the script, press the Cancel button


EXTERN

EXTERN Advanced Global Transformations

An extern advanced global transformation is a Java or Voyager 2 function that can be called from the Advanced Global Transformation Assistant. Such a function must comply with the following rules:

  • A Java method declaration must have the following form:

    import JIDBM.*;
    import java.lang.String;
    import …;

    public class Transfo
    {

    …

    public static void function_name(int[] list_of_objects, int confirmation)
    {

    int i;
    dbmLibrary lib = new dbmLibrary();
    dbmEntityType et;

    for (i=0; i<list_of_objects.length; i++) {
    if (lib.getObjectTypeOfGenericObject(list_of_objects[i])==dbmGenericObject.ENTITY_TYPE) {
    et = new dbmEntityType(list_of_objects[i]);

    …

    }

    }

    …

    }

    …

    }

  • A Voyager 2 function header must have the following form:

    export function integer function_name (list : list_of_objects, integer : confirmation)

  • In these definitions, the list_of_objects parameter is a list of objects of the DB-MAIN repository (actual objects in Voyager 2, object ids in Java). Consequently, the function must check the type of objects before transforming them.

  • The confirmation parameter is a boolean value: 0 if the function can be executed without confirmation, 1 if the function must ask for confirmation before transforming each object of the list.

  • These functions must return a boolean value: 0 if no transformation has been performed, any other value if at least one transformation was actually.


Transformation library

A transformation library is a list of small advanced global transformation scripts that can be reused in new scripts. New entries can be added and existing ones can be deleted or edited. Such a library can be saved to disk and reloaded.

When the Transformation library dialog box is open, the Library list is filled with the current library entries in alphabetical order.

When an entry in the library is selected, its definition appears in the Script list. The selected entry can be edited in the same way as in the Advanced global transformation dialog box, except that it cannot include other library entries.

New library entries may be added with the Add button at any time. A name must be given in a specific dialog box. The new entry is then added to the list and the Script list is cleared.

To delete the selected entry, press the Delete button.

To save a library, press the Save library button (transformation libraries have a .tlf extension).

To open an existing library, press the Load library button.

A default library can be defined in the DB-MAIN configuration (File/Configuration…/Transformations). This library is automatically loaded the first time the Advanced global transformation assistant is called during a DB-MAIN session.


Analysis assistant

Schema analysis assistant

Presentation

Constraints on schemas

Constraints on collections

Constraints on entity types

Constraints on is-a relations

Constraints on rel-types

Constraints on roles

Constraints on attributes

Constraints on groups

Constraints on entity type identifiers

Constraints on rel-type identifiers

Constraints on attribute identifiers

Constraints on access keys

Constraints on referential groups

Constraints on processing units

Constraints on data objects

Constraints on object states

Constraints on action states

Constraints on control flows

Constraints on object flows

Constraints on use cases

Constraints on actors

Constraints on extend relationships

Constraints on include relationships

Constraints on use case generalizations

Constraints on associations

Constraints on use case association roles

Constraints on actor association roles

Constraints on actor generalization

Constraints on names

Constraints on meta-properties

Plug-in constraints


Analysis assistant presentation

Presentation of the Schema Analysis Assistant

The Schema Analysis Assistant allows to achieve two goals:

- | Search: to find objects in a schema that verify specific properties;
- | Validation: to validate a schema according to specific rules.
The Search and Validate buttons (top left of the window) allow to choose the preferred job. The line to their right indicates the current selection.
The Rules text area lists the properties that will be evaluated during the analysis process. These properties are specified with first-order logic predicative rules.
A rule is a formula in which operators are the boolean AND, OR and NOT and operands are predicates.
A predicate is a built-in function that returns TRUE if a given object verifies a given property and FALSE otherwise. Such built-in functions may require some parameters.
The properties to check are defined as a set of rules. Such a set is called a script. Scripts can contain comments. Comments are lines of free text that can be used to improve the readability of scripts. They can be inserted between rules only (not between predicates inside a rule). They have no impact on the evaluation job.
The execution of a script gives the following results:
Search mode: for each rule, all the objects of the current schema that verify this rule are reported.
Validation mode: for each rule, all the objects of the current schema that violate this rule are reported.
Example :
 | Let us suppose that the script is made of the following rule :
 | ATT_per_RT(0 0)
 | or ROLE_per_RT (2 2)
Search mode: all rel-types having no attributes or exactly 2 roles will be reported.
Validation mode: all rel-types having attributes or any number of roles but two will be reported.
How to define a script ?
Each object type listed in the Object list has a corresponding Constraints list. The latter contains all the predefined predicates that are applicable to this object type. All the predicates of one rule must belong to a same Constraints list. Rules can be stored in a library.
A script is defined as follows:
1. | Select an object type in the Objects list.
2. | Select a constraint in the Constraints list or a name in the Library list or check the Comment box.
3. | Either push the Add button (or double-click on the predicate or the name) to add the selected item at the end of the script or select a line in the script and push the Insert button to insert the selected item before the selected line.
4. | When adding a predicate, fill in the parameters line in the Add/Insert constraint dialog box. The Help button gives information on the predicate and the required format for parameters. Check the box of the operator(s) that must be put before the predicate (AND, OR, NOT). When specifying the first predicate of a rule, only the NOT operator is available. For other predicates, either AND or OR must be checked (possibly associated with NOT).
 | When adding a comment, fill in the text field in the Comment dialog box.
5. | Repeat 1 3 until the script is complete.
The Remove button removes the selected predicate from the script.
The Edit button (or a double-click on a predicate in the script) opens the Add/Insert constraint window to change the parameters of the selected predicate if necessary.
The Clear button erases the script.
The Predefined button gives a list of built-in scripts. If one of them is selected, it is displayed in the Rules list and can then be modified or executed.
The Load button allows to open a previously saved script.
The Save button allows to save the current script.
The Edit library button allows to manage the current library of analysis rules.
The Copy button copies the script to the clipboard.
How to use a script ?
The Ok button allows to perform a search or validation job using the current script. It closes the window, keeping the script in memory for reuse during the same DB-MAIN session.
The Cancel button closes the window discarding the changes made to the script and without executing it.
Report window
As soon as the job is finished, a window is displayed. If there is no result at all, this window is a simple message box. Otherwise, the window displays the first rule of the script and reports the list of objects verifying (or violating) this rule.
The Next (resp. Previous) button (available only when necessary) allows to display the report on the next (resp. previous) rule of the script.
When an object is selected in the report list, a Goto button is enabled. A click on it or a double click on the selected item activates the window containing the analysed schema; the specified object is automatically selected and centred in the middle of the window.
The Report button allows to save the report to a file.


Edit library of analysis rules

Edit the library of analysis rules

An library of analysis rules is a list of named rules made of schema analysis constraints. Editing such a library allows to add new entries, delete or edit existing ones. It can be saved to disk and loaded.

When the Edit Library dialog box is opened, the Library list displays the current library entries.

When a library entry is selected, its definition appears in the Rule list. Except for some restrictions, this rule can then be edited in the same way as in the Schema analysis dialog box. An entry can only contain one rule and it cannot include other library entries. Comments can be added before or after the rule.

The New button allows to define a new library entry. A specific dialog box requires a name for the new rule and the object type on which it is defined. After confirmation, it is added to the Library list in alphabetical order and the Rule list is cleared.

The Delete button allows to delete obsolete library entries. It deletes the currently selected one.

The Save library button allows to save the current library to disk in a file (with a .anl extension).

The Load library button allows to open a previously saved library.

A default library can be defined in the configuration (File/Configuration…/Schema analysis). This library is automatically loaded the first time the Schema Analysis Assistant is called during a DB-MAIN session.


Constraints on schema

Constraints on schemas

ET_per_SCHEMA <min> <max>

Description

Returns true if the schema contains between <min> and <max> entity types.

This constraint is only suitable to ERA schemas or UML class diagrams.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

RT_per_SCHEMA <min> <max>

Description

Returns true if the schema contains between <min> and <max> rel-types.

This constraint is only suitable to ERA schemas or UML class diagrams.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

COLL_per_SCHEMA <min> <max>

Description

Returns true if the schema contains between <min> and <max> collections.

This constraint is only suitable to ERA schemas or UML class diagrams.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

ACTION_STATE_per_SCHEMA <min> <max>

Description

Returns true if the schema contains between <min> and <max> action states.

This constraint is only suitable to UML activity diagrams.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

OBJECT_STATE_per_SCHEMA <min> <max>

Description

Returns true if the schema contains between <min> and <max> object states.

This constraint is only suitable to UML activity diagrams.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

ACTOR_per_SCHEMA <min> <max>

Description

Returns true if the schema contains between <min> and <max> actors.

This constraint is only suitable to UML use case diagrams.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

USECASE_per_SCHEMA <min> <max>

Description

Returns true if the schema contains between <min> and <max> use cases.

This constraint is only suitable to UML use case diagrams.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

ASSOC_per_SCHEMA <min> <max>

Description

Returns true if the schema contains between <min> and <max> associations.

This constraint is only suitable to UML use case diagrams.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

META_PROP_of_SCHEMA <meta-property> <parameters>

Description

Checks some properties of a meta-property of the schema.

Parameters

See Constraints on meta-properties.

SELECTED_SCHEMA

Description

Searches for all selected schemas. This constraint should not be used for validation.

Parameters

None.

MARKED_SCHEMA

Description

Searches for all marked schemas. This constraint should not be used for validation.

Parameters

None.

PLUGIN_CONSTRAINT_on_SCHEMA <file> <function> <parameters>

Description

Calls a plug-in boolean function. This constraint returns the result of the function. It provides an easy way to add new constraints.

Parameters

See plug-in constraints


Constraints on collections

ALL_COLL

Description

Searches for all collections. It should not be used for validation.

Parameters

None.

ET_per_COLL <min> <max>

Description

Returns true if the collection contains between <min> and <max> entity types.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

META_PROP_of_COLL <meta-property> <parameters>

Description

Checks some properties of a meta-property of the collection.

Parameters

See Constraints on meta-properties.

SELECTED_COLL

Description

Searches for all selected collections. This constraint should not be used for validation.

Parameters

None.

MARKED_COLL

Description

Searches for all marked collections. This constraint should not be used for validation.

Parameters

None.

PLUGIN_CONSTRAINT_on_COLL <file> <function> <parameters>

Description

Calls a plug-in boolean function. This constraint returns the result of the function. It provides an easy way to add new constraints.

Parameters

See plug-in constraints


Constraints on entity types

ALL_ET

Description

Searches for all entity types. It should not be used for validation.

Parameters

None.

ATT_per_ET <min> <max>

Description

Returns true if the entity type contains between <min> and <max> attributes.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

ATT_LENGTH_per_ET <min> <max>

Description

Returns true if the total length of the attributes (sum of their respective lengths) of the entity type is between <min> and <max>.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

ROLE_per_ET <min> <max>

Description

Returns true if the entity type plays between <min> and <max> roles.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

ONE_ROLE_per_ET <min> <max>

Description

Returns true if the entity type plays between <min> and <max> roles that have a maximum cardinality of 1.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

N_ROLE_per_ET <min> <max>

Description

Returns true if the entity type plays between <min> and <max> roles that have a maximum cardinality of N.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

MAND_ROLE_per_ET <min> <max>

Description

Returns true if the entity type plays between <min> and <max> mandatory roles.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

OPT_ROLE_per_ET <min> <max>

Description

Returns true if the entity type plays between <min> and <max> optional roles.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

GROUP_per_ET <min> <max>

Description

Returns true if the entity type contains between <min> and <max> groups.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

ID_per_ET <min> <max>

Description

Returns true if the entity type has between <min> and <max> identifiers.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

PID_per_ET <min> <max>

Description

Returns true if the entity type has between <min> and <max> primary identifiers.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

ALL_ATT_in_ID_ET <yn>

Description

<yn> = yes: returns true if every identifier of the entity type contains all its attributes (with or without roles) or if the entity type has no explicit identifier.

<yn> = no: returns true if the entity type has at least one identifier that does not contain all its attributes.

Parameters

<yn> is either yes or no.

ALL_ATT_ID_per_ET <min> <max>

Description

Returns true if the entity type has between <min> and <max> identifiers made of attributes only.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

HYBRID_ID_per_ET <min> <max>

Description

Returns true if the entity type has between <min> and <max> hybrid identifiers (i.e. made of attributes and roles).

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

KEY_ID_per_ET <min> <max>

Description

Returns true if the entity type has between <min> and <max> identifiers that are access keys.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

ID_NOT_KEY_per_ET <min> <max>

Description

Returns true if the entity type has between <min> and <max> identifiers that are not access keys.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

KEY_ALL_ATT_ID_per_ET <min> <max>

Description

Returns true if the entity type has between <min> and <max> identifiers made of attributes only and that are access keys.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

OVERLAPPING_ID_per_ET <min> <max>

Description

Returns true if the entity type has between <min> and <max> overlapping identifiers.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

ID_DIFF_in_ET <type>

Description

Returns true if the identifiers of the entity type are all different.

The similarity criteria depend on the <type> parameter :

  • components: two identifiers are identical if they have exactly the same components, whatever their order of appearance;

  • components_and_order: two identifiers are identical if, on the one hand, they have exactly the same components, and, on the other hand, these components appear in the same order.

    Example: an entity type has two identifiers, one made of attributes A and B, the other made of attributes B and A. If the <type> parameter is components, these identifiers are considered identical; if the <type> parameter is components_and_order, they are considered different.

    Parameters

    <type> is either components or components_and_order.

    KEY_per_ET <min> <max>

    Description

    Returns true if the entity type contains between <min> and <max> access key groups.

    Parameters

    <min> is an integer constant;

    <max> is an integer constant or the special value N (meaning any positive integer).

    ALL_ATT_KEY_per_ET <min> <max>

    Description

    Returns true if the entity type contains between <min> and <max> access key groups made of attributes only.

    Parameters

    <min> is an integer constant;

    <max> is an integer constant or the special value N (meaning any positive integer).

    HYBRID_KEY_per_ET <min> <max>

    Description

    Returns true if the entity type has between <min> and <max> hybrid access key groups.

    Parameters

    <min> is an integer constant;

    <max> is an integer constant or the special value N (meaning any positive integer).

    ID_KEY_per_ET <min> <max>

    Description

    Returns true if the entity type contains between <min> and <max> access key groups that are identifiers too.

    Parameters

    <min> is an integer constant;

    <max> is an integer constant or the special value N (meaning any positive integer).

    KEY_PREFIX_in_ET <type>

    Description

    Returns true if the entity type has an access key that is a prefix of another access key or identifier.

    The <value> parameter specifies whether the order of attributes must be taken into account or not.

    This constraint is mostly used in Search mode. To use it in order to validate a schema, it should be used with the negation operator (not KEY_PREFIX_in_ET).

    Parameters

    <type> is either same_order or any_order.

    REF_per_ET <min> <max>

    Description

    Returns true if the entity type contains between <min> and <max> referential groups.

    Parameters

    <min> is an integer constant;

    <max> is an integer constant or the special value N (meaning any positive integer).

    REF_in_ET <type>

    Description

    Returns true if the entity type contains at least one reference constraint that references group(s) of type <type>.

    Parameters

    <type> is either pid (to find ET that have group(s) referencing primary identifiers) or sid (to find ET that have group(s) referencing secondary identifiers).

    COEXIST_per_ET <min> <max>

    Description

    Returns true if the entity type contains between <min> and <max> coexistence groups.

    Parameters

    <min> is an integer constant;

    <max> is an integer constant or the special value N (meaning any positive integer).

    EXCLUSIVE_per_ET <min> <max>

    Description

    Returns true if the entity type contains between <min> and <max> exclusive groups.

    Parameters

    <min> is an integer constant;

    <max> is an integer constant or the special value N (meaning any positive integer).

    ATLEASTONE_per_ET <min> <max>

    Description

    Returns true if the entity type contains between <min> and <max> at-least-one groups.

    Parameters

    <min> is an integer constant;

    <max> is an integer constant or the special value N (meaning any positive integer).

    INCLUDE_per_ET <min> <max>

    Description

    Returns true if the entity type contains between <min> and <max> inclusion groups.

    Parameters

    <min> is an integer constant;

    <max> is an integer constant or the special value N (meaning any positive integer).

    INVERSE_per_ET <min> <max>

    Description

    Returns true if the entity type contains between <min> and <max> inverse groups.

    Parameters

    <min> is an integer constant;

    <max> is an integer constant or the special value N (meaning any positive integer).

    GENERIC_per_ET <min> <max>

    Description

    Returns true if the entity type contains between <min> and <max> generic constraints.

    Parameters

    <min> is an integer constant;

    <max> is an integer constant or the special value N (meaning any positive integer).

    PROCUNIT_per_ET

    Description

    Returns true if the entity type contains between <min> and <max> processing units.

    Parameters

    <min> is an integer constant;

    <max> is an integer constant or the special value N (meaning any positive integer).

    COLL_per_ET <min> <max>

    Description

    Returns true if the entity type belongs to minimum <min> and maximum <max> collections.

    Parameters

    <min> is an integer constant;

    <max> is an integer constant or the special value N (meaning any positive integer).

    META_PROP_of_ET <meta-property> <parameters>

    Description

    Checks some properties of a meta-property of the entity type.

    Parameters

    See Constraints on meta-properties.

    SELECTED_ET

    Description

    Searches for all selected entity types. This constraint should not be used for validation.

    Parameters

    None.

    MARKED_ET

    Description

    Searches for all marked entity types. This constraint should not be used for validation.

    Parameters

    None.

    PLUGIN_CONSTRAINT_on_ET <file> <function> <parameters>

    Description

    Calls a plug-in boolean function. This constraint returns the result of the function. It provides an easy way to add new constraints.

    Parameters

    See plug-in constraints


Constraints on is-a relations

ALL_ISA

Description

Searches for all super-types. It should not be used for validation.

Parameters

None.

SUB_TYPES_per_ISA <min> <max>

Description

Returns true if the entity type has between <min> and <max> sub-types.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

SUPER_TYPES_per_ISA <min> <max>

Description

Returns true if the entity type has between <min> and <max> super-types.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

TOTAL_in_ISA <yn>

Description

Returns true if the entity type is the super-type of a is-a relation having (yes) or not having (no) the total attribute.

Parameters

<yn> is either yes or no.

DISJOINT_in_ISA <yn>

Description

Returns true if the entity type is the super-type of a is-a relation having (yes) or not having (no) the disjoint attribute

Parameters

<yn> is either yes or no.

META_PROP_of_ISA <meta-property> <parameters>

Description

Checks some properties of a meta-property of the super-type.

Parameters

See Constraints on meta-properties.

SELECTED_ISA

Description

Searches for all selected super-types. This constraint should not be used for validation.

Parameters

None.

MARKED_ISA

Description

Searches for all marked super-types. This constraint should not be used for validation.

Parameters

None.

PLUGIN_CONSTRAINT_on_ISA <file> <function> <parameters>

Description

Calls a plug-in boolean function. This constraint returns the result of the function. It provides an easy way to add new constraints.

Parameters

See plug-in constraints


Constraints on rel-types

ALL_RT

Description

Searches for all rel-types. It should not be used for validation.

Parameters

None.

ATT_per_RT <min> <max>

Description

Returns true if the rel-type contains between <min> and <max> attributes.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

ATT_LENGTH_per_RT <min> <max>

Description

Returns true if the total length of the attributes (sum of their respective lengths) of the rel-type is between <min> and <max>.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

ROLE_per_RT <min> <max>

Description

Returns true if the rel-type has between <min> and <max> roles.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

ONE_ROLE_per_RT <min> <max>

Description

Returns true if the rel-type has between <min> and <max> roles that have a maximum cardinality of 1.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

N_ROLE_per_RT <min> <max>

Description

Returns true if the rel-type has between <min> and <max> roles that have a maximum cardinality of N.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

MAND_ROLE_per_RT <min> <max>

Description

Returns true if the rel-type has between <min> and <max> mandatory roles.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

OPT_ROLE_per_RT <min> <max>

Description

Returns true if the rel-type has between <min> and <max> optional roles.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

RECURSIVITY_in_RT <min> <max>

Description

Returns true if an entity type plays between <min> and <max> roles in the rel-type.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

GROUP_per_RT <min> <max>

Description

Returns true if the rel-type has between <min> and <max> groups.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

ID_per_RT <min> <max>

Description

Returns true if the rel-type has between <min> and <max> identifiers.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

PID_per_RT <min> <max>

Description

Returns true if the rel-type has between <min> and <max> primary identifiers.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

ALL_ATT_ID_per_RT <min> <max>

Description

Returns true if the rel-type has between <min> and <max> identifiers made of attributes only.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

HYBRID_ID_per_RT <min> <max>

Description

Returns true if the rel-type has between <min> and <max> hybrid identifiers (i.e. made of attributes and roles).

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

OVERLAPPING_ID_per_RT <min> <max>

Description

Returns true if the rel-type has between <min> and <max> overlapping identifiers.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

ID_DIFF_in_RT <type>

Description

Returns true if the identifiers of the rel-type are all different.

The similarity criteria depend on the <type> parameter :

  • components: two identifiers are identical if they have exactly the same components, whatever their order of appearance;

  • components_and_order: two identifiers are identical if, on the one hand, the have exactly the same components, and, on the other hand, these components appear in the same order.

    Example: a rel-type has two identifiers, one made of attributes A and B, the other made of attributes B and A. If the <type> parameter is components, these identifiers are considered identical; if the <type> parameter is components_and_order, they are considered different.

    Parameters

    <type> is either components or components_and_order.

    KEY_per_RT <min> <max>

    Description

    Returns true if the rel-type has between <min> and <max> access keys.

    Parameters

    <min> is an integer constant;

    <max> is an integer constant or the special value N (meaning any positive integer).

    COEXIST_per_RT <min> <max>

    Description

    Returns true if the rel-type has between <min> and <max> coexistence groups.

    Parameters

    <min> is an integer constant;

    <max> is an integer constant or the special value N (meaning any positive integer).

    EXCLUSIVE_per_RT <min> <max>

    Description

    Returns true if the rel-type has between <min> and <max> exclusive groups.

    Parameters

    <min> is an integer constant;

    <max> is an integer constant or the special value N (meaning any positive integer).

    ATLEASTONE_per_RT <min> <max>

    Description

    Returns true if the rel-type has between <min> and <max> at-least-one groups.

    Parameters

    <min> is an integer constant;

    <max> is an integer constant or the special value N (meaning any positive integer).

    INCLUDE_per_RT <min> <max>

    Description

    Returns true if the rel-type has between <min> and <max> inclusion groups.

    Parameters

    <min> is an integer constant;

    <max> is an integer constant or the special value N (meaning any positive integer).

    GENERIC_per_RT <min> <max>

    Description

    Returns true if the rel-type has between <min> and <max> generic constraints.

    Parameters

    <min> is an integer constant;

    <max> is an integer constant or the special value N (meaning any positive integer).

    PROCUNIT_per_RT

    Description

    Returns true if the rel-type has between <min> and <max> processing units.

    Parameters

    <min> is an integer constant;

    <max> is an integer constant or the special value N (meaning any positive integer).

    META_PROP_of_RT <meta-property> <parameters>

    Description

    Checks some properties of a meta-property of the rel-type.

    Parameters

    See Constraints on meta-properties.

    SELECTED_RT

    Description

    Searches for all selected rel-types. This constraint should not be used for validation.

    Parameters

    None.

    MARKED_RT

    Description

    Searches for all marked rel-types. This constraint should not be used for validation.

    Parameters

    None.

    PLUGIN_CONSTRAINT_on_RT <file> <function> <parameters>

    Description

    Calls a plug-in boolean function. This constraint returns the result of the function. It provides an easy way to add new constraints.

    Parameters

    See plug-in constraints


Constraints on roles

ALL_ROLE

Description

Searches for all roles. It should not be used for validation.

Parameters

None.

MIN_CARD_of_ROLE <min> <max>

Description

Returns true if the minimum cardinality of the role is between <min> and <max>.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

MAX_CARD_of_ROLE <min> <max>

Description

Returns true if the maximum cardinality of the role is between <min> and <max>.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

ET_per_ROLE <min> <max>

Description

Returns true if the number of entity types that play the role is between <min> and <max>.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

META_PROP_of_ROLE <meta-property> <parameters>

Description

Checks some properties of a meta-property of the role.

Parameters

See Constraints on meta-properties.

SELECTED_ROLE

Description

Searches for all selected roles. This constraint should not be used for validation.

Parameters

None.

MARKED_ROLE

Description

Searches for all marked roles. This constraint should not be used for validation.

Parameters

None.

PLUGIN_CONSTRAINT_on_ROLE <file> <function> <parameters>

Description

Calls a plug-in boolean function. This constraint returns the result of the function. It provides an easy way to add new constraints.

Parameters

See plug-in constraints


Constraints on attributes

ALL_ATT

Description

Searches for all attributes. It should not be used for validation.

Parameters

None.

MIN_CARD_of_ATT <min> <max>

Description

Returns true if the minimum cardinality of the attribute is between <min> and <max>.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

MAX_CARD_of_ATT <min> <max>

Description

Returns true if the maximum cardinality of the attribute is between <min> and <max>.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

DEPTH_of_ATT <min> <max>

Description

Returns true if the depth of the attribute is between <min> and <max>.

The depth of an attribute is the amount of encompassing compound attributes plus one.

For instance, DEPTH_of_ATT 2 N matches all sub-attributes.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

SUB_ATT_per_ATT <min> <max>

Description

Returns true if the attribute has between <min> and <max> sub-attributes.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

TYPES_ALLOWED_for_ATT <list>

Description

Returns true if the attribute type is mentioned in the <list> parameter.

Parameters

<list> is the list of allowed types separated by spaces (possible types are: BOOLEAN, CHAR, DATE, FLOAT, NUMERIC, VARCHAR, COMPOUND, OBJECT, USER, SEQUENCE, INDEX).

TYPES_NOTALLOWED_for_ATT <list>

Description

Returns true if the attribute type is not mentioned in the <list> parameter.

Parameters

<list> is the list of forbidden types separated by spaces (possible types are: BOOLEAN, CHAR, DATE, FLOAT, NUMERIC, VARCHAR, COMPOUND, OBJECT, USER, SEQUENCE, INDEX.

SET_TYPES_ALLOWED_for_ATT <list>

Description

Returns true if the multivalued attribute set type is mentioned in the <list> parameter.

Parameters

<list> is the list of all allowed set types separated by spaces (possible set types are: SET, BAG, LIST, UNIQUELIST, ARRAY, UNIQUEARRAY).

SET_TYPES_NOTALLOWED_for_ATT <list>

Description

Returns true if the multivalued attribute set type is not mentioned in the <list> parameter.

Parameters

<list> is the list of all forbidden set types, separated by spaces: SET BAG LIST UNIQUELIST ARRAY UNIQUEARRAY.

TYPE_DEF_for_ATT <type> <parameters>

Description

Checks specific properties on attributes of a given type. For instance, to match all NUMERIC attributes coded with 1 to 5 digits and 0 to 2 decimals, the following constraint must be used:

TYPE_DEF_for_ATT NUMERIC 1 5 0 2

Parameters

<type> is the type of attribute for which the parameters will be evaluated.

<parameters> is the list of parameters for the chosen type; the content of that list depends on the type :

CHAR <min. length> <max. length>

FLOAT <min. size> <max. size>

NUMERIC <min. size> <max. size> <min. decimals> <max. decimals>

VARCHAR <min. length> <max. length>

BOOLEAN <min. size> <max. size>

DATE <min. size> <max. size>

COMPOUND <min. size> <max. size>

SEQUENCE <min. size> <max. size>

INDEX <min. size> <max. size>

USER <min. size> <max. size> <min. cardinality> <max. cardinality> <min. depth> <max. depth>

PART_of_GROUP_ATT <min> <max>

Description

Returns true if the attribute is a component of at least <min> and at most <max> groups.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

ID_per_ATT <min> <max>

Description

Returns true if the attribute has between <min> and <max> identifiers.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

PID_per_ATT <min> <max>

Description

Returns true if the attribute has between <min> and <max> primary identifiers.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

PART_of_ID_ATT <min> <max>

Description

Returns true if the attribute is a component of at least <min> and at most <max> identifiers.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

KEY_per_ATT <min> <max>

Description

Returns true if the compound attribute contains between <min> and <max> access keys.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

REF_per_ATT <min> <max>

Description

Returns true if the compound attribute contains between <min> and <max> referential groups.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

PART_of_REF_ATT <min> <max>

Description

Returns true if the attribute is a component of at least <min> and at most <max> referential groups.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

META_PROP_of_ATT <meta-property> <parameters>

Description

Checks some properties of a meta-property of the attribute.

Parameters

See Constraints on meta-properties.

SELECTED_ATT

Description

Searches for all selected attributes. This constraint should not be used for validation.

Parameters

None.

MARKED_ATT

Description

Searches for all marked attributes. This constraint should not be used for validation.

Parameters

None.

PLUGIN_CONSTRAINT_on_ATT <file> <function> <parameters>

Description

Calls a plug-in boolean function. This constraint returns the result of the function. It provides an easy way to add new constraints.

Parameters

See plug-in constraints


Constraints on groups

ALL_GROUP

Description

Searches for all groups. It should not be used for validation.

Parameters

None.

COMP_per_GROUP <min> <max>

Description

Returns true if the group contains between <min> and <max> terminal components. A component is terminal if it is not a group.

Example: A is a group made of an attribute a and another group B. B is made of two attributes b1 and b2. In this case A has three terminal components : a, b1 and b2.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

ATT_per_GROUP <min> <max>

Description

Returns true if the group contains between <min> and <max> attributes.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

ROLE_per_GROUP <min> <max>

Description

Returns true if the group contains between <min> and <max> roles.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

GROUP_per_GROUP <min> <max>

Descrition

Returns true if the group contains between <min> and <max> groups.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

ID_in_GROUP <yn>

Description

Returns true if the group is (yes) or is not (no) an identifier.

Parameters

<yn> is either yes or no.

PID_in_GROUP <yn>

Description

Returns true if the group is (yes) or is not (no) a primary identifier.

Parameters

<yn> is either yes or no.

KEY_in_GROUP <yn>

Description

Returns true if the group is (yes) or is not (no) an access key.

Parameters

<yn> is either yes or no.

REF_in_GROUP <yn>

Description

Returns true if the group is (yes) or is not (no) a referential group.

Parameters

<yn> is either yes or no.

COEXIST_in_GROUP <yn>

Description

Returns true if the group is (yes) or is not (no) a coexistence group.

Parameters

<yn> is either yes or no.

EXCLUSIVE_in_GROUP <yn>

Description

Returns true if the group is (yes) or is not (no) an exclusive group.

Parameters

<yn> is either yes or no.

ATLEASTONE_in_GROUP <yn>

Description

Returns true if the group is (yes) or is not (no) an at-least-one group.

Parameters

<yn> is either yes or no.

INCLUDE_in_GROUP <yn>

Description

Returns true if the group is (yes) or is not (no) an inclusion group.

Parameters

<yn> is either yes or no.

INVERSE_in_GROUP <yn>

Description

Returns true if the group is (yes) or is not (no) an inverse group.

Parameters

<yn> is either yes or no.

GENERIC_in_GROUP <yn>

Description

Returns true if the group is (yes) or is not (no) a generic constraint group.

Parameters

<yn> is either yes or no.

LENGTH_of_ATT_GROUP <min> <max>

Description

Returns true if the total length of the components (sum of their respective lengths) of the group is between <min> and <max>.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

TRANSITIVE_GROUP <yn>

Description

Returns true if the group is transitive (yes) or not transitive (no). For instance, let A(a,b), B(a,b) and C(b) be 3 entity types. (A.a,A.b) is a group involved in a constraint with the group (B.a,B.b), (A.b) is a group involved in a constraint with the group (C.b) and (B.b) is a group involved in a constraint with the group (C.b). In that case, the group (A.b) involved in a constraint with the group (C.b) is said to be the origin of a transitive group.

The type of the constraints are not taken into account.

Parameters

<yn> is either yes or no.

META_PROP_of_GROUP <meta-property> <parameters>

Description

Checks some properties of a meta-property of the group.

Parameters

See Constraints on meta-properties.

SELECTED_GROUP

Description

Searches for all selected groups. This constraint should not be used for validation.

Parameters

None.

MARKED_GROUP

Description

Searches for all marked groups. This constraint should not be used for validation.

Parameters

None.

PLUGIN_CONSTRAINT_on_GROUP <file> <function> <parameters>

Description

Calls a plug-in boolean function. This constraint returns the result of the function. It provides an easy way to add new constraints.

Parameters

See plug-in constraints


Constraints on entity type identifiers

ALL_EID

Description

Searches for all entity type identifiers. It should not be used for validation.

Parameters

None.

COMP_per_EID <min> <max>

Description

Returns true if the entity type identifier has between <min> and <max> components.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

ATT_per_EID <min> <max>

Description

Returns true if the entity type identifier contains between <min> and <max> attributes.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

OPT_ATT_per_EID <min> <max>

Description

Returns true if the entity type identifier contains between <min> and <max> optional attributes.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

MAND_ATT_per_EID <min> <max>

Description

Returns true if the entity type identifier contains between <min> and <max> mandatory attributes.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

SINGLE_ATT_per_EID <min> <max>

Description

Returns true if the entity type identifier contains between <min> and <max> single-valued attributes.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

MULT_ATT_per_EID <min> <max>

Description

Returns true if the entity type identifier contains between <min> and <max> multivalued attributes.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

MULT_ATT_per_MULT_COMP_EID <min> <max>

Description

Returns true if the multi-component entity type identifier contains between <min> and <max> multivalued attributes.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

SUB_ATT_per_EID <min> <max>

Description

Returns true if the entity type identifier contains between <min> and <max> sub-attributes.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

COMP_ATT_per_EID <min> <max>

Description

Returns true if the entity type identifier contains between <min> and <max> compound attributes.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

ROLE_per_EID <min> <max>

Description

Returns true if the entity type identifier contains between <min> and <max> roles.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

OPT_ROLE_per_EID <min> <max>

Description

Returns true if the entity type identifier contains between <min> and <max> optional roles.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

MAND_ROLE_per_EID <min> <max>

Description

Returns true if the entity type identifier contains between <min> and <max> mandatory roles.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

ONE_ROLE_per_EID <min> <max>

Description

Returns true if the entity type identifier contains between <min> and <max> single-valued roles.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

N_ROLE_per_EID <min> <max>

Description

Returns true if the entity type identifier contains between <min> and <max> multivalued roles.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

GROUP_per_EID <min> <max>

Description

Returns true if the entity type identifier contains between <min> and <max> groups.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

ALL_EPID

Description

Searches for all entity type primary identifiers. It should not be used for validation.

Parameters

None.

COMP_per_EPID <min> <max>

Description

Returns true if the entity type primary identifier has between <min> and <max> components.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

ATT_per_EPID <min> <max>

Description

Returns true if the entity type primary identifier contains between <min> and <max> attributes.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

OPT_ATT_per_EPID <min> <max>

Description

Returns true if the entity type primary identifier contains between <min> and <max> optional attributes.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

MAND_ATT_per_EPID <min> <max>

Description

Returns true if the entity type primary identifier contains between <min> and <max> mandatory attributes.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

SINGLE_ATT_per_EPID <min> <max>

Description

Returns true if the entity type primary identifier contains between <min> and <max> single-valued attributes.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

MULT_ATT_per_EPID <min> <max>

Description

Returns true if the entity type primary identifier contains between <min> and <max> multivalued attributes.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

MULT_ATT_per_MULT_COMP_EPID <min> <max>

Description

Returns true if the multi-component entity type primary identifier contains between <min> and <max> multivalued attributes.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

SUB_ATT_per_EPID <min> <max>

Description

Returns true if the entity type primary identifier contains between <min> and <max> sub-attributes.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

COMP_ATT_per_EPID <min> <max>

Description

Returns true if the entity type primary identifier contains between <min> and <max> compound attributes.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

ROLE_per_EPID <min> <max>

Description

Returns true if the entity type primary identifier contains between <min> and <max> roles.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

OPT_ROLE_per_EPID <min> <max>

Description

Returns true if the entity type primary identifier contains between <min> and <max> optional roles.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

MAND_ROLE_per_EPID <min> <max>

Description

Returns true if the entity type primary identifier contains between <min> and <max> mandatory roles.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

ONE_ROLE_per_EPID <min> <max>

Description

Returns true if the entity type primary identifier contains between <min> and <max> single-valued roles.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

N_ROLE_per_EPID <min> <max>

Description

Returns true if the entity type primary identifier contains between <min> and <max> multivalued roles.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

GROUP_per_EPID <min> <max>

Description

Returns true if the entity type primary identifier contains between <min> and <max> groups.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

META_PROP_of_EID <meta-property> <parameters>

Description

Checks some properties of a meta-property of the entity type identifier.

Parameters

See Constraints on meta-properties.

SELECTED_EID

Description

Searches for all selected entity type identifiers. This constraint should not be used for validation.

Parameters

None.

MARKED_EID

Description

Searches for all marked entity type identifiers. This constraint should not be used for validation.

Parameters

None.

PLUGIN_CONSTRAINT_on_EID <file> <function> <parameters>

Description

Calls a plug-in boolean function. This constraint returns the result of the function. It provides an easy way to add new constraints.

Parameters

See plug-in constraints


Constraints on rel-type identifiers

ALL_RID

Description

Searches for all rel-type identifiers. It should not be used for validation.

Parameters

None.

COMP_per_RID <min> <max>

Description

Returns true if the rel-type identifier has between <min> and <max> components.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

ATT_per_RID <min> <max>

Description

Returns true if the rel-type identifier contains between <min> and <max> attributes.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

OPT_ATT_per_RID <min> <max>

Description

Returns true if the rel-type identifier contains between <min> and <max> optional attributes.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

MAND_ATT_per_RID <min> <max>

Description

Returns true if the rel-type identifier contains between <min> and <max> mandatory attributes.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

SINGLE_ATT_per_RID <min> <max>

Description

Returns true if the rel-type identifier contains between <min> and <max> single-valued attributes.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

MULT_ATT_per_RID <min> <max>

Description

Returns true if the rel-type identifier has between <min> and <max> multivalued attributes.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

MULT_ATT_per_MULT_COMP_RID <min> <max>

Description

Returns true if the multi-component rel-type identifier contains between <min> and <max> multivalued attributes.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

SUB_ATT_per_RID <min> <max>

Description

Returns true if the rel-type identifier contains between <min> and <max> sub-attributes.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

COMP_ATT_per_RID <min> <max>

Description

Returns true if the rel-type identifier contains between <min> and <max> compound attributes.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

ROLE_per_RID <min> <max>

Description

Returns true if the rel-type identifier contains between <min> and <max> roles.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

OPT_ROLE_per_RID <min> <max>

Description

Returns true if the rel-type identifier contains between <min> and <max> optional roles.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

MAND_ROLE_per_RID <min> <max>

Description

Returns true if the rel-type identifier contains between <min> and <max> mandatory roles.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

ONE_ROLE_per_RID <min> <max>

Description

Returns true if the rel-type identifier contains between <min> and <max> single-valued roles.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

N_ROLE_per_RID <min> <max>

Description

Returns true if the rel-type identifier contains between <min> and <max> multivalued roles.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

GROUP_per_RID <min> <max>

Description

Returns true if the rel-type identifier contains between <min> and <max> groups.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

ALL_RPID

Description

Searches for all rel-type primary identifiers. It should not be used for validation.

Parameters

None.

COMP_per_RPID <min> <max>

Description

Returns true if the rel-type primary identifier has between <min> and <max> components.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

ATT_per_RPID <min> <max>

Description

Returns true if the rel-type primary identifier contains between <min> and <max> attributes.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

OPT_ATT_per_RPID <min> <max>

Description

Returns true if the rel-type primary identifier contains between <min> and <max> optional attributes.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

MAND_ATT_per_RPID <min> <max>

Description

Returns true if the rel-type primary identifier contains between <min> and <max> mandatory attributes.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

SINGLE_ATT_per_RPID <min> <max>

Description

Returns true if the rel-type primary identifier contains between <min> and <max> single-valued attributes.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

MULT_ATT_per_RPID <min> <max>

Description

Returns true if the rel-type primary identifier contains between <min> and <max> multivalued attributes.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

MULT_ATT_per_MULT_COMP_RPID <min> <max>

Description

Returns true if the multi-component rel-type primary identifier contains between <min> and <max> multivalued attributes.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

SUB_ATT_per_RPID <min> <max>

Description

Returns true if the rel-type primary identifier contains between <min> and <max> sub-attributes.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

COMP_ATT_per_RPID <min> <max>

Description

Returns true if the rel-type primary identifier contains between <min> and <max> compound attributes.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

ROLE_per_RPID <min> <max>

Description

Returns true if the rel-type primary identifier contains between <min> and <max> roles.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

OPT_ROLE_per_RPID <min> <max>

Description

Returns true if the rel-type primary identifier contains between <min> and <max> optional roles.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

MAND_ROLE_per_RPID <min> <max>

Description

Returns true if the rel-type primary identifier contains between <min> and <max> mandatory roles.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

ONE_ROLE_per_RPID <min> <max>

Description

Returns true if the rel-type primary identifier contains between <min> and <max> single-valued roles.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

N_ROLE_per_RPID <min> <max>

Description

Returns true if the rel-type primary identifier contains between <min> and <max> multivalued roles.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

GROUP_per_RPID <min> <max>

Description

Returns true if the rel-type primary identifier contains between <min> and <max> groups.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

META_PROP_of_RID <meta-property> <parameters>

Description

Checks some properties of a meta-property of the rel-type identifier.

Parameters

See Constraints on meta-properties.

SELECTED_RID

Description

Searches for all selected rel-type identifiers. This constraint should not be used for validation.

Parameters

None.

MARKED_RID

Description

Searches for all marked rel-type identifiers. This constraint should not be used for validation.

Parameters

None.

PLUGIN_CONSTRAINT_on_RID <file> <function> <parameters>

Description

Calls a plug-in boolean function. This constraint returns the result of the function. It provides an easy way to add new constraints.

Parameters

See plug-in constraints


Constraints on attribute identifiers

ALL_AID

Description

Searches for all attribute identifiers. It should not be used for validation.

Parameters

None.

COMP_per_AID <min> <max>

Description

Returns true if the attribute identifier has between <min> and <max> components.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

ATT_per_AID <min> <max>

Description

Returns true if the attribute identifier contains between <min> and <max> attributes.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

OPT_ATT_per_AID <min> <max>

Description

Returns true if the attribute identifier contains between <min> and <max> optional attributes.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

MAND_ATT_per_AID <min> <max>

Description

Returns true if the attribute identifier contains between <min> and <max> mandatory attributes.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

SINGLE_ATT_per_AID <min> <max>

Description

Returns true if the attribute identifier contains between <min> and <max> single-valued attributes.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

MULT_ATT_per_AID <min> <max>

Description

Returns true if the attribute identifier contains between <min> and <max> multivalued attributes.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

MULT_ATT_per_MULT_COMP_AID <min> <max>

Description

Returns true if the multi-component attribute identifier contains between <min> and <max> multivalued attributes.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

SUB_ATT_per_AID <min> <max>

Description

Returns true if the attribute identifier contains between <min> and <max> sub-attributes.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

COMP_ATT_per_AID <min> <max>

Description

Returns true if the attribute identifier contains between <min> and <max> compound attributes.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

GROUP_per_AID <min> <max>

Description

Returns true if the attribute identifier contains between <min> and <max> groups.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

ALL_APID

Description

Searches for all attribute primary identifiers. It should not be used for validation.

Parameters

None.

COMP_per_APID <min> <max>

Description

Returns true if the attribute primary identifier has between <min> and <max> components.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

ATT_per_APID <min> <max>

Description

Returns true if the attribute primary identifier contains between <min> and <max> attributes.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

OPT_ATT_per_APID <min> <max>

Description

Returns true if the attribute primary identifier contains between <min> and <max> optional attributes.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

MAND_ATT_per_APID <min> <max>

Description

Returns true if the attribute primary identifier contains between <min> and <max> mandatory attributes.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

SINGLE_ATT_per_APID <min> <max>

Description

Returns true if the attribute primary identifier contains between <min> and <max> single-valued attributes.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

MULT_ATT_per_APID <min> <max>

Description

Returns true if the attribute primary identifier contains between <min> and <max> multivalued attributes.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

MULT_ATT_per_MULT_COMP_APID <min> <max>

Description

Returns true if the multi-component attribute primary identifier contains between <min> and <max> multivalued attributes.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

SUB_ATT_per_APID <min> <max>

Description

Returns true if the attribute primary identifier contains between <min> and <max> sub-attributes.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

COMP_ATT_per_APID <min> <max>

Description

Returns true if the attribute primary identifier contains between <min> and <max> compound attributes.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

GROUP_per_APID <min> <max>

Descrition

Returns true if the attribute primary identifier contains between <min> and <max> groups.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

META_PROP_of_AID <meta-property> <parameters>

Description

Checks some properties of a meta-property of the attribute identifier.

Parameters

See Constraints on meta-properties.

SELECTED_AID

Description

Searches for all selected attribute identifiers. This constraint should not be used for validation.

Parameters

None.

MARKED_AID

Description

Searches for all marked attribute identifiers. This constraint should not be used for validation.

Parameters

None.

PLUGIN_CONSTRAINT_on_AID <file> <function> <parameters>

Description

Calls a plug-in boolean function. This constraint returns the result of the function. It provides an easy way to add new constraints.

Parameters

See plug-in constraints


Constraints on access keys

ALL_KEY

Description

Searches for all access keys. It should not be used for validation.

Parameters

None.

COMP_per_KEY <min> <max>

Description

Returns true if the access key has between <min> and <max> components.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

ATT_per_KEY <min> <max>

Description

Returns true if the access key contains between <min> and <max> attributes.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

OPT_ATT_per_KEY <min> <max>

Description

Returns true if the access key contains between <min> and <max> optional attributes.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

MAND_ATT_per_KEY <min> <max>

Description

Returns true if the access key contains between <min> and <max> mandatory attributes.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

SINGLE_ATT_per_KEY <min> <max>

Description

Returns true if the access key contains between <min> and <max> single-valued attributes.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

MULT_ATT_per_KEY <min> <max>

Description

Returns true if the access key contains between <min> and <max> multivalued attributes.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

MULT_ATT_per_MULT_COMP_KEY <min> <max>

Description

Returns true if the multi-component access key contains between <min> and <max> multivalued attributes.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

SUB_ATT_per_KEY <min> <max>

Description

Returns true if the access key contains between <min> and <max> sub-attributes.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

COMP_ATT_per_KEY <min> <max>

Description

Returns true if the access key contains between <min> and <max> compound attributes.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

ROLE_per_KEY <min> <max>

Description

Returns true if the access key contains between <min> and <max> roles.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

OPT_ROLE_per_KEY <min> <max>

Description

Returns true if the access key contains between <min> and <max> optional roles.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

MAND_ROLE_per_KEY <min> <max>

Description

Returns true if the access key contains between <min> and <max> mandatory roles.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

ONE_ROLE_per_KEY <min> <max>

Description

Returns true if the access key contains between <min> and <max> single-valued roles.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

N_ROLE_per_KEY <min> <max>

Description

Returns true if the access key contains between <min> and <max> multivalued roles.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

GROUP_per_KEY <min> <max>

Description

Returns true if the access key contains between <min> and <max> groups.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

META_PROP_of_KEY <meta-property> <parameters>

Description

Checks some properties of a meta-property of the access key.

Parameters

See Constraints on meta-properties.

SELECTED_KEY

Description

Searches for all selected access keys. This constraint should not be used for validation.

Parameters

None.

MARKED_KEY

Description

Searches for all marked access keys. This constraint should not be used for validation.

Parameters

None.

PLUGIN_CONSTRAINT_on_KEY <file> <function> <parameters>

Description

Calls a plug-in boolean function. This constraint returns the result of the function. It provides an easy way to add new constraints.

Parameters

See plug-in constraints


Constraints on referential groups

ALL_REF

Description

Searches for all referential groups. It should not be used for validation.

Parameters

None.

COMP_per_REF <min> <max>

Description

Returns true if the referential group has between <min> and <max> components.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

ATT_per_REF <min> <max>

Description

Returns true if the referential group contains between <min> and <max> attributes.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

OPT_ATT_per_REF <min> <max>

Description

Returns true if the referential group contains between <min> and <max> optional attributes.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

MAND_ATT_per_REF <min> <max>

Description

Returns true if the referential group contains between <min> and <max> mandatory attributes.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

SINGLE_ATT_per_REF <min> <max>

Description

Returns true if the referential group contains between <min> and <max> single-valued attributes.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

MULT_ATT_per_REF <min> <max>

Description

Returns true if the referential group contains between <min> and <max> multivalued attributes.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

MULT_ATT_per_MULT_COMP_REF <min> <max>

Description

Returns true if the multi-component referential group contains between <min> and <max> multivalued attributes.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

SUB_ATT_per_REF <min> <max>

Description

Returns true if the referential group contains between <min> and <max> sub-attributes.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

COMP_ATT_per_REF <min> <max>

Description

Returns true if the referential group contains between <min> and <max> compound attributes.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

ROLE_per_REF <min> <max>

Description

Returns true if the referential group contains between <min> and <max> roles.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

OPT_ROLE_per_REF <min> <max>

Description

Returns true if the referential group contains between <min> and <max> optional roles.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

MAND_ROLE_per_REF <min> <max>

Description

Returns true if the referential group contains between <min> and <max> mandatory roles.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

ONE_ROLE_per_REF <min> <max>

Description

Returns true if the referential group contains between <min> and <max> single-valued roles.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

N_ROLE_per_REF <min> <max>

Description

Returns true if the referential group contains between <min> and <max> multivalued roles.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

GROUP_per_REF <min> <max>

Description

Returns true if the referential group contains between <min> and <max> groups.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

LENGTH_of_REF <operator>

Description

Returns true if the total length of the components (sum of their respective lengths) of the referential group verifies the operator <operator> when compared to the length of the referenced group.

Parameters

<operator> is either equal, different, smaller or greater.

TRANSITIVE_REF <yn>

Description

Returns true if the referential group is transitive (yes) or not transitive (no). For instance, let A(a,b), B(a,b) and C(b) be 3 entity types. (A.a,A.b) references (B.a,B.b), A.b references C.b and B.b references C.b. In that case, the referential constraint A.b -> C.b is redundant and should be suppressed.

Parameters

<yn> is either yes or no.

META_PROP_of_REF <meta-property> <parameters>

Description

Checks some properties of a meta-property of the referential constraint.

Parameters

See Constraints on meta-properties.

SELECTED_REF

Description

Searches for all selected referential groups. This constraint should not be used for validation.

Parameters

None.

MARKED_REF

Description

Searches for all marked referential groups. This constraint should not be used for validation.

Parameters

None.

PLUGIN_CONSTRAINT_on_REF <file> <function> <parameters>

Description

Calls a plug-in boolean function. This constraint returns the result of the function. It provides an easy way to add new constraints.

Parameters

See plug-in constraints


Constraints on processing units

ALL_PROCUNIT

Description

Searches for all processing units. It should not be used for validation.

Parameters

None.

META_PROP_of_PROCUNIT <meta-property> <parameters>

Description

Checks some properties of a meta-property of the processing unit.

Parameters

See Constraints on meta-properties.

SELECTED_PROCUNIT

Description

Searches for all selected processing units. This constraint should not be used for validation.

Parameters

None.

MARKED_PROCUNIT

Description

Searches for all marked processing units. This constraint should not be used for validation.

Parameters

None.

PLUGIN_CONSTRAINT_on_PROCUNIT <v2-file> <v2-predicate> <parameters>

Description

Calls a plug-in boolean function. This constraint returns the result of the function. It provides an easy way to add new constraints.

Parameters

See plug-in constraints


Constraints on data objects

Constraints on data objetcs

ALL_DATAOBJ

Description

Searches for all data objects. It should not be used for validation.

Parameters

None.

STATE_per_DATAOBJ <min> <max>

Description

Returns true if the data object is shown by <min> to <max> states.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

IS_INTERN_DATAOBJ <yn>

Description

<yn> = yes: returns true if the data object is an internal one, declared into the schema only.

<yn> = no: returns true if the data object is not internal, declared into another schema and just referenced in the current schema.

Parameters

<yn> is either yes or no.

IS_EXTERN_DATAOBJ <yn>

Description

<yn> = yes: returns true if the data object is an external one, declared into another schema and referenced in the current schema.

<yn> = no: returns true if the data object is not external, declared into the current schema.

Parameters

<yn> is either yes or no.

META_PROP_of_DATAOBJ <meta-property> <parameters>

Description

Checks some properties of a meta-property of the data objects.

Parameters

See Constraints on meta-properties.

PLUGIN_CONSTRAINT_on_DATAOBJ <file> <function> <parameters>

Description

Calls a plug-in boolean function. This constraint returns the result of the function. It provides an easy way to add new constraints.

Parameters

See plug-in constraints


Constraints on object states

ALL_OBJSTATE

Description

Searches for all . It should not be used for validation.

Parameters

None.

OBJECT_FLOW_per_OBJSTATE <min> <max>

Description

Returns true if the object state participates in <min> to <max> flows.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

META_PROP_of_OBJSTATE <meta-property> <parameters>

Description

Checks some properties of a meta-property of the object state.

Parameters

See Constraints on meta-properties.

SELECTED_OBJSTATE

Description

Searches for all selected object states. This constraint should not be used for validation.

Parameters

None.

MARKED_OBJSTATE

Description

Searches for all marked object states. This constraint should not be used for validation.

Parameters

None.

PLUGIN_CONSTRAINT_on_OBJSTATE <file> <function> <parameters>

Description

Calls a plug-in boolean function. This constraint returns the result of the function. It provides an easy way to add new constraints.

Parameters

See plug-in constraints


Constraints on action states

Constraints on action state

ALL_ACTIONSTATE

Description

Searches for all action states. It should not be used for validation.

Parameters

None.

TYPE_of_ACTIONSTATE <type>

Description

Returns true if the action state is of the specified type.

Parameters

<type> is either USER, INITIAL, FINAL, SYNCHRONIZATION (either horizontal or vertical), DECISION, SIGNALSEND, SIGNALRECEIPT, or ANY (any of the previous ones).

CONTROL_FLOW_from_ACTIONSTATE <min> <max>

Description

Returns true if the number of control flows leaving an action state is between <min> and <max>.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

CONTROL_FLOW_to_ACTIONSTATE <min> <max>

Description

Returns true if the number of control flows reaching an action state is between <min> and <max>.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

OBJECT_FLOW_per_ACTIONSTATE <min> <max>

Description

Returns true if the number of object flows leaving or reaching an action state is between <min> and <max>.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

META_PROP_of_ACTIONSTATE <meta-property> <parameters>

Description

Checks some properties of a meta-property of the action state.

Parameters

See Constraints on meta-properties.

SELECTED_ACTIONSTATE

Description

Searches for all selected action states. This constraint should not be used for validation.

Parameters

None.

MARKED_ACTIONSTATE

Description

Searches for all marked action states. This constraint should not be used for validation.

Parameters

None.

PLUGIN_CONSTRAINT_on_ACTIONSTATE <file> <function> <parameters>

Description

Calls a plug-in boolean function. This constraint returns the result of the function. It provides an easy way to add new constraints.

Parameters

See plug-in constraints


Constraints on control flows

ALL_CTRLFLOW

Description

Searches for all control flows. It should not be used for validation.

Parameters

None.

META_PROP_of_CTRLFLOW <meta-property> <parameters>

Description

Checks some properties of a meta-property of the control flows.

Parameters

See Constraints on meta-properties.

SELECTED_CTRLFLOW

Description

Searches for all selected control flows. This constraint should not be used for validation.

Parameters

None.

MARKED_CTRLFLOW

Description

Searches for all marked control flows. This constraint should not be used for validation.

Parameters

None.

PLUGIN_CONSTRAINT_on_CTRLFLOW <file> <function> <parameters>

Description

Calls a plug-in boolean function. This constraint returns the result of the function. It provides an easy way to add new constraints.

Parameters

See plug-in constraints


Constraints on object flows

ALL_OBJFLOW

Description

Searches for all object flows. It should not be used for validation.

Parameters

None.

META_PROP_of_OBJFLOW <meta-property> <parameters>

Description

Checks some properties of a meta-property of the object flows.

Parameters

See Constraints on meta-properties.

SELECTED_OBJFLOW

Description

Searches for all selected object flows. This constraint should not be used for validation.

Parameters

None.

MARKED_OBJFLOW

Description

Searches for all marked object flows. This constraint should not be used for validation.

Parameters

None.

PLUGIN_CONSTRAINT_on_OBJFLOW <file> <function> <parameters>

Description

Calls a plug-in boolean function. This constraint returns the result of the function. It provides an easy way to add new constraints.

Parameters

See plug-in constraints


Constraints on use cases

ALL_USECASE

Description

Searches for all use cases. It should not be used for validation.

Parameters

None.

ASSOC_per_USECASE <min> <max>

Description

Returns true if the use case is involved in <min> to <max> associations.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

EXTEND_USECASE <min> <max>

Description

Returns true if the use case extends <min> to <max> other use cases.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

IS_EXTENDED_by_USECASE <min> <max>

Description

Returns true if the use case is extended by <min> to <max> other use cases.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

INCLUDE_USECASE <min> <max>

Description

Returns true if the use case includes <min> to <max> other use cases.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

IS_INCLUDED_in_USECASE <min> <max>

Description

Returns true if the use case is included in <min> to <max> other use cases.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

GENERALIZATION_per_USECASE <min> <max>

Description

Returns true if the use case is the generalization of <min> to <max> other use cases.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

SPECIALIZATION_per_USECASE <min> <max>

Description

Returns true if the use case is the generalization of <min> to <max> other use cases.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

META_PROP_of_USECASE <meta-property> <parameters>

Description

Checks some properties of a meta-property of the use cases.

Parameters

See Constraints on meta-properties.

SELECTED_USECASE

Description

Searches for all selected use cases. This constraint should not be used for validation.

Parameters

None.

MARKED_USECASE

Description

Searches for all marked use cases. This constraint should not be used for validation.

Parameters

None.

PLUGIN_CONSTRAINT_on_USECASE <file> <function> <parameters>

Description

Calls a plug-in boolean function. This constraint returns the result of the function. It provides an easy way to add new constraints.

Parameters

See plug-in constraints


Constraints on actors

ALL_ACTOR

Description

Searches for all actors. It should not be used for validation.

Parameters

None.

ASSOC_per_ACTOR <min> <max>

Description

Returns true if the actor is involved in <min> to <max> associations.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

GENERALIZATION_per_ACTOR <min> <max>

Description

Returns true if the actor is the generalization of <min> to <max> other actors.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

SPECIALIZATION_per_ACTOR <min> <max>

Description

Returns true if the actor is the generalization of <min> to <max> other actors.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

META_PROP_of_ACTOR <meta-property> <parameters>

Description

Checks some properties of a meta-property of the actors.

Parameters

See Constraints on meta-properties.

SELECTED_ACTOR

Description

Searches for all selected actors. This constraint should not be used for validation.

Parameters

None.

MARKED_ACTOR

Description

Searches for all marked actors. This constraint should not be used for validation.

Parameters

None.

PLUGIN_CONSTRAINT_on_ACTOR <file> <function> <parameters>

Description

Calls a plug-in boolean function. This constraint returns the result of the function. It provides an easy way to add new constraints.

Parameters

See plug-in constraints


Constraints on extend relationships

ALL_EXTEND

Description

Searches for all extend relationships. It should not be used for validation.

Parameters

None.

META_PROP_of_EXTEND <meta-property> <parameters>

Description

Checks some properties of a meta-property of the extend relationships.

Parameters

See Constraints on meta-properties.

SELECTED_EXTEND

Description

Searches for all selected extend relationships. This constraint should not be used for validation.

Parameters

None.

MARKED_EXTEND

Description

Searches for all marked extend relationships. This constraint should not be used for validation.

Parameters

None.

PLUGIN_CONSTRAINT_on_EXTEND <file> <function> <parameters>

Description

Calls a plug-in boolean function. This constraint returns the result of the function. It provides an easy way to add new constraints.

Parameters

See plug-in constraints


Constraints on include relationships

ALL_INCLUDE

Description

Searches for all include relationships. It should not be used for validation.

Parameters

None.

META_PROP_of_INCLUDE <meta-property> <parameters>

Description

Checks some properties of a meta-property of the include relationships.

Parameters

See Constraints on meta-properties.

SELECTED_INCLUDE

Description

Searches for all selected include relationships. This constraint should not be used for validation.

Parameters

None.

MARKED_INCLUDE

Description

Searches for all marked include relationships. This constraint should not be used for validation.

Parameters

None.

PLUGIN_CONSTRAINT_on_INCLUDE <file> <function> <parameters>

Description

Calls a plug-in boolean function. This constraint returns the result of the function. It provides an easy way to add new constraints.

Parameters

See plug-in constraints


Constraints on use case generalizations

ALL_UCGENERAL

Description

Searches for all use case generalizations. It should not be used for validation.

Parameters

None.

META_PROP_of_UCGENERAL <meta-property> <parameters>

Description

Checks some properties of a meta-property of the use case generalizations.

Parameters

See Constraints on meta-properties.

SELECTED_UCGENERAL

Description

Searches for all selected use case generalizations. This constraint should not be used for validation.

Parameters

None.

MARKED_UCGENERAL

Description

Searches for all marked use case generalizations. This constraint should not be used for validation.

Parameters

None.

PLUGIN_CONSTRAINT_on_UCGENERAL <file> <function> <parameters>

Description

Calls a plug-in boolean function. This constraint returns the result of the function. It provides an easy way to add new constraints.

Parameters

See plug-in constraints


Constraints on associations

ALL_ASSOC

Description

Searches for all associations. It should not be used for validation.

Parameters

None.

ROLE_per_ASSOC <min> <max>

Description

Returns true if the association has between <min> and <max> roles.

Parameters

<min> is an integer constant;

<max> is an integer constant (always £ 2).

ONE_ROLE_per_ASSOC <min> <max>

Description

Returns true if the association has between <min> and <max> roles that have a maximum cardinality of 1.

Parameters

<min> is an integer constant;

<max> is an integer constant (always £ 2).

N_ROLE_per_ASSOC <min> <max>

Description

Returns true if the association has between <min> and <max> roles that have a maximum cardinality of N.

Parameters

<min> is an integer constant;

<max> is an integer constant (always £ 2).

MAND_ROLE_per_ASSOC <min> <max>

Description

Returns true if the association has between <min> and <max> mandatory roles.

Parameters

<min> is an integer constant;

<max> is an integer constant (always £ 2).

OPT_ROLE_per_ASSOC <min> <max>

Description

Returns true if the association has between <min> and <max> optional roles.

Parameters

<min> is an integer constant;

<max> is an integer constant (always £ 2).

META_PROP_of_ASSOC <meta-property> <parameters>

Description

Checks some properties of a meta-property of the associations.

Parameters

See Constraints on meta-properties.

SELECTED_ASSOC

Description

Searches for all selected associations. This constraint should not be used for validation.

Parameters

None.

MARKED_ASSOC

Description

Searches for all marked associations. This constraint should not be used for validation.

Parameters

None.

PLUGIN_CONSTRAINT_on_ASSOC <file> <function> <parameters>

Description

Calls a plug-in boolean function. This constraint returns the result of the function. It provides an easy way to add new constraints.

Parameters

See plug-in constraints


Constraints on use case association roles

ALL_UCASSOC

Description

Searches for all use case association roles. It should not be used for validation.

Parameters

None.

MIN_CARD_of_UCASSOC <min> <max>

Description

Returns true if the minimum cardinality of the use case association role is between <min> and <max>.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

MAX_CARD_of_UCASSOC <min> <max>

Description

Returns true if the maximum cardinality of the use case association role is between <min> and <max>.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

META_PROP_of_UCASSOC <meta-property> <parameters>

Description

Checks some properties of a meta-property of the use case association roles.

Parameters

See Constraints on meta-properties.

SELECTED_UCASSOC

Description

Searches for all selected use case association roles. This constraint should not be used for validation.

Parameters

None.

MARKED_UCASSOC

Description

Searches for all marked use case association roles. This constraint should not be used for validation.

Parameters

None.

PLUGIN_CONSTRAINT_on_UCASSOC <file> <function> <parameters>

Description

Calls a plug-in boolean function. This constraint returns the result of the function. It provides an easy way to add new constraints.

Parameters

See plug-in constraints


Constraints on actor association roles

ALL_ACTASSOC

Description

Searches for all actor association roles. It should not be used for validation.

Parameters

None.

MIN_CARD_of_ACTASSOC <min> <max>

Description

Returns true if the minimum cardinality of the actor association role is between <min> and <max>.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

MAX_CARD_of_ACTASSOC <min> <max>

Description

Returns true if the maximum cardinality of the actor association role is between <min> and <max>.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

META_PROP_of_ACTASSOC <meta-property> <parameters>

Description

Checks some properties of a meta-property of the actor association roles.

Parameters

See Constraints on meta-properties.

SELECTED_ACTASSOC

Description

Searches for all selected actor association roles. This constraint should not be used for validation.

Parameters

None.

MARKED_ACTASSOC

Description

Searches for all marked actor association roles. This constraint should not be used for validation.

Parameters

None.

PLUGIN_CONSTRAINT_on_ACTASSOC <file> <function> <parameters>

Description

Calls a plug-in boolean function. This constraint returns the result of the function. It provides an easy way to add new constraints.

Parameters

See plug-in constraints


Constraints on actor generalizations

ALL_ACTORGENERAL

Description

Searches for all actor generalizations. It should not be used for validation.

Parameters

None.

META_PROP_of_ACTORGENERAL <meta-property> <parameters>

Description

Checks some properties of a meta-property of the actor generalizations.

Parameters

See Constraints on meta-properties.

SELECTED_ACTORGENERAL

Description

Searches for all selected actor generalizations. This constraint should not be used for validation.

Parameters

None.

MARKED_ACTORGENERAL

Description

Searches for all marked actor generalizations. This constraint should not be used for validation.

Parameters

None.

PLUGIN_CONSTRAINT_on_ACTORGENERAL <file> <function> <parameters>

Description

Calls a plug-in boolean function. This constraint returns the result of the function. It provides an easy way to add new constraints.

Parameters

See plug-in constraints


Constraints on names

CONCERNED_NAMES <list>

Description

This predicate allows to reduce the scope of other predicates on names to the objects of the types specified in the <list> parameter. Thus it should only be used together with other predicates on names. For instance, to match all names but those of entity types and rel-types of 8 characters or less, the following rule can be used :

CONCERNED_NAMES ET RT (this rule applies to ET and RT names)

and LENGTH_of_NAMES 1 8 (their length must be between 1 and 8 characters)

or not CONCERNED_NAMES ET RT (names of all objects but ET and RT are accepted too)

Parameters

<list> is a list of object types separated by spaces. Valid names for object types are those used as suffixes for all predicates: SCHEMA, COLL, ET, RT, ATT, ROLE, ATT, GROUP, EID, EPID, RID, RPID, AID, APID, KEY, REF, PROCUNIT, DATAOBJ, OBJSTATE, ACTIONSTATE, USECASE, ACTOR.

NONE_in_LIST_NAMES <list>

Description

Returns true if the name of the schema, entity type, rel-type, attribute, role or group is not mentioned in the <list> list. Comparisons beween list entries and object names are case sensitive.

Parameters

<list> is a list of words separated by commas. All the characters between two commas belong to a word, spaces included. The word syntax is the same as the one used by the name processor. Hence, it is possible to use the following special characters : ^ stands for the beginning of a line, $ stands for the end of a line, ? stands for any single character and * stands for any string of characters. For instance : ^_*, *_$ forbids any name that begins with _ or ends with _.

NONE_in_LIST_CI_NAMES <list>

Description

Returns true if the name of the schema, entity type, rel-type, attribute, role or group is not mentioned in the <list> list. Comparisons beween list entries and object names are case insensitive.

Parameters

<list> is a list of words separated by commas. All the characters between two commas belong to a word, spaces included. See the NONE_in_LIST_NAMES constraint for details on the word syntax.

ALL_in_LIST_NAMES <list>

Description

Returns true if the name of the schema, entity type, rel-type, attribute, role or group is mentioned in the <list> list. Comparisons beween list entries and object names are case sensitive.

Parameters

<list> is a list of words separated by commas. All the characters between two commas belong to a word, spaces included. See the NONE_in_LIST_NAMES constraint for details on the word syntax.

ALL_in_LIST_CI_NAMES <list>

Description

Returns true if the name of the schema, entity type, rel-type, attribute, role or group is not mentioned in the list <list>. Comparisons beween list entries and object names are case insensitive.

Parameters

<list> is a list of words separated by a comma. All the characters between two commas belong to a word, spaces included. See the NONE_in_LIST_NAMES constraint for details on the word syntax.

NONE_in_FILE_NAMES <name of file>

Description

Returns true if the name of the schema, entity type, rel-type, attribute, role or group is not mentioned in the <name of file> file. Comparisons beween list entries and object names are case sensitive.

Parameters

<name of file> is the name of an ASCII file that contains the list of forbidden names. Each line of this file contains a name. All characters of a line are part of the name, except for the end of line character. See the NONE_in_LIST_NAMES constraint for details on the word syntax.

NONE_in_FILE_CI_NAMES <name of file>

Description

Returns true if the name of the schema, entity type, rel-type, attribute, role or group is not mentioned in the <name of file> file. Comparisons beween list entries and object names are case insensitive.

Parameters

<name of file> is the name of an ASCII file that contains the list of forbidden names. Each line of this file contains a name. All characters of a line are part of the name, except for the end of line character. See the NONE_in_LIST_NAMES constraint for details on the word syntax.

ALL_in_FILE_NAMES <name of file>

Description

Returns true if the name of the schema, entity type, rel-type, attribute, role or group is mentioned in the <name of file> file. Comparisons beween list entries and object names are case sensitive.

Parameters

<name of file> is the name of an ASCII file that contains the list of allowed names. Each line of this file contains a name. All characters of a line are part of the name, except for the end of line character. See the NONE_in_LIST_NAMES constraint for details on the word syntax.

ALL_in_FILE_CI_NAMES <name of file>

Description

Returns true if the name of the schema, entity type, rel-type, attribute, role or group is mentioned in the <name of file> file. Comparisons beween list entries and object names are case insensitive.

Parameters

<name of file> is the name of an ASCII file that contains the list of allowed names. Each line of this file contains a name. All characters of a line are part of the name, except for the end of line character. See the NONE_in_LIST_NAMES constraint for details on the word syntax.

NO_CHARS_in_LIST_NAMES <list>

Description

Returns true if the name of the schema, entity type, rel-type, attribute, role or group does not contain any of the characters mentioned in the <list> list.

Parameters

<list> is a list of characters without separators. For example : &é"'()§è!çà{}@#[]

ALL_CHARS_in_LIST_NAMES <list>

Description

Returns true if the name of the schema, entity type, rel-type, attribute, role or group is made only of characters mentioned in the <list> list.

Parameters

<list> is a list of characters without separators. For example : ABCDEFGHIJKLMNOPQRSTUVWXYZ

LENGTH_of_NAMES <min> <max>

Description

Returns true if the length of the name of the schema, entity type, rel-type, attribute, role or group is between <min> and <max>.

Parameters

<min> is an integer constant;

<max> is an integer constant or the special value N (meaning any positive integer).

UNIQUE_among_NAMES <scope>

Description

Returns true if the name is unique within the given scope.

Parameters

<scope> can be one of these keywords:

schema: checks whether a name is unique within the whole schema.

type: checks whether a name is unique among all the constructs of the same type within the schema.

siblings: checks whether a name is unique among all the constructs hosted by the same object. For instance, attributes of the same level in the same entity type, entity types, rel-types (their common host is the schema).

siblings_type: checks whether a name is unique among all the constructs of the same type that are hosted by the same object.

META_PROP_of_NAMES <meta-property> <parameters>

Description

Checks some properties of a meta-property of the objects having a name compliant with the other constraints of the same rule.

Parameters

See Constraints on meta-properties.

SELECTED_NAMES

Description

Search for all selected names. This constraint should not be used for validation.

Parameters

None.

MARKED_NAMES

Description

Search for all marked names. This constraint should not be used for validation.

Parameters

None.

PLUGIN_CONSTRAINT_on_NAMES <file> <function> <parameters>

Description

Calls a plug-in boolean function. This constraint returns the result of the function. It provides an easy way to add new constraints.

Parameters

See plug-in constraints


Using meta-property constraints

Constraints on meta-properties

Constraints on meta-properties take two parameters and have the following signature:

META_PROP_of_XXX <meta-property> <parameters>
where:
 | XXX is either SCHEMA, COLL, ET, ISA, RT, ROLE, ATT, GROUP, EID, RID, AID, KEY, REF, PROCUNIT, DATAOBJ, OBJSTATE, ACTIONSTATE, CTRLFLOW, OBJFLOW, USECASE, ACTOR, EXTEND, INCLUDE, UCGENERAL, ASSOC, UCASSOC, ACTASSOC, ACTORGENERAL, NAMES, representing the type of objects that will be analysed;
 | <meta-property> is the name of a meta-property defined on constructs of type XXX. If the name contains a space character, it must be surrounded by double quotes. The name itself cannot contain double quotes. E.g.: owner, "account number" are valid names.
 | <parameters> is a list of parameters, the number and the type of which depend on the <meta-property> as described below.
The meta-property can be declared either single-valued or multivalued.
If the meta-property is multivalued, the <parameters> string is one of the following:
 | count <min> <max>
 | In this case, the number of values (whatever they are) must be between <min> (integer value) and <max> (positive integer value or N)'
 | one <single-valued meta-property parameters>
 | In this case exactly one of the values must verify the <single-valued meta-property parameters> parameter. Each value is treated as if the meta-property was single-valued; all the values that satisfy the property are counted and the multi-valued property is said to be satisfied if the count equals one.
 | some <single-valued meta-property parameters>
 | In this case at least one of the values must verify the <single-valued meta-property parameters> parameter. Each value is treated as if the meta-property was single-valued; all the values that satisfy the property are counted and the multi-valued property is said to be satisfied if the count is greater or equal to 0.
 | each <single-valued meta-property parameters>
 | In this case, all values must verify the <single-valued meta-property parameters> parameter. Each value is treated as if the meta-property was single-valued and the multi-valued property is said to be satisfied if every value satisfy the "single-valued property".
If the meta-property is single-valued (or one value of a multi-valued property is analysed), the <parameters> string format depends on the type of the meta-property:
 | Integer: <parameters> is : <min> <max>
 | The meta-property value must be between <min> (integer value) and <max> (positive integer value or N).
 | Char: <parameters> is <min> <max>
 | The meta-property value must be between (in ASCII order) <min> and <max> (character constants).
 | Real: <parameters> is <min> <max>
 | The meta-property value must be between <min> and <max> (real constants).
 | Boolean: <parameters> is either true or false
 | The meta-property value must be either true or false.
 | String: <parameters> is <comparison operator> <string>
 | The comparison operator must be =, <, >, =ci, <ci, >ci, or contains:
 | = is the strict equality of both <string> and the meta-property value;
 | < means <string> comes before the meta-property value in alphabetical order;
 | > means <string> comes after the meta-property value in alphabetical order;
 | =ci, <ci and >ci are the case insensitive equivalents of =, <, >;
 | contains is the sub-string operator that checks whether <string> is a sub-string of the meta-property value.
Examples
 | META_PROP_of_ATT (view count 2 N)
 | Searches for all attributes used in at least two views (view is the DB-MAIN built-in meta-property for the definition of views)
 | META_PROP_of_ET(owner = "T. Smith")
 | Assuming that owner is a single-valued meta-property of type string defined on entity types, this constraint looks for all entity types owned by T. Smith.
 | META_PROP_of_ET("modified by" some contains Smith)
 | Assuming that modified by is a multi-valued meta-property of type string defined on entity types that contains the list of all the persons that have modified the entity type, this constraint looks for all entity types modified by Smith.
 | META_PROP_of_ATT(line 50 60)
 | line is a single-valued meta-property of type integer defined on all constructs generated by the COBOL extractor. This constraint looks for all constructs obtained from the extraction of a specific part (lines 50-60) of the COBOL source file.


Using plug-in constraints

Plug-in constraints

Plug-in constraints allow DB-MAIN users to build their own constraints, in Voyager 2 or in Java, on any type of objects. They are called PLUGIN_CONSTRAINT_on_<name-of-object-type>.

These constraints make it possible to look for complex patterns that cannot be expressed through simple predefined constraints.

Plug-in constraints take three parameters and have the following signature :

PLUGIN_CONSTRAINT_on_XXX <file> <function> <parameters>
where
 | XXX is either SCHEMA, COLL, ET, ISA, RT, ROLE, ATT, GROUP, EID, RID, AID, KEY, REF, PROCUNIT, DATAOBJ, OBJSTATE, ACTIONSTATE, CTRLFLOW, OBJFLOW, USECASE, ACTOR, EXTEND, INCLUDE, UCGENERAL, ASSOC, UCASSOC, ACTASSOC, ACTORGENERAL, NAMES, representing the type of objects that will be analysed;
 | <file> is the name of the plug-in program that contains the function implementing the constraint, its extension, mandatory, must be either “.oxo” for a Voyager 2 program or “.class” for a Java program;
 | <function> is the name of the plug-in function as described below;
 | <parameters> represents its parameters.
Voyager 2 constraint
A Voyager 2 plug-in function must be declared as an exportable integer function that takes two parameters: the object of the repository that must be analysed (entity type for instance) and a string containing all the required parameters. This function must return 0 if the constraint is not verified and any other value otherwise.
Example:
Let Num_tech_id_per_et be the name of a plug-in function that checks the number of technical identifiers in an entity type. It is in the program ANALYSIS.V2, compiled as ANALYSIS.OXO in the C:\PROJECT directory. This function has two parameters (minimum required number and maximum allowed number of technical identifiers). This function will be declared as follows in the ANALYSIS.V2 file:
 | export function integer Num_tech_id_per_et(entity_type: ent, string: arguments)
 | type : variable;…
 | {
 | …
 | }
and the constraint in the script will look like:
 | PLUGIN_CONSTRAINT_on_ET C:\PROJECT\ANALYSIS.OXO Num_tech_id_per_et 0 1
Java constraint
A Java plug-in constraint must be a static public method declared in any class. It must take two parameters, the object id of the object of the repository that must be analysed (entity type for instance) and a string containing all the required parameters, and return an integer, 0 if the constraint is not verified and any other value otherwise.
Example:
Let Num_tech_id_per_et be the name of a plug-in function that checks the number of technical identifiers in an entity type. Let us suppose it is declared in a class named Analysis. The Analysis.java file should look like:
 | import JIDBM.*;
 | import java.lang.String;
 | import …;
 | public class Analysis
 | {
 | …
 | public static int Num_tech_id_per_et(into oid, String s)
 | {
 | dbmLibrary lib = new dbmLibrary();
 | dbmEntityType et;
 | if (lib.getObjectTypeOfGenericObject(oid)==dbmGenericObject.ENTITY_TYPE) {
 | et = new dbmEntityType(oid);
 | …
 | }
 | …
 | }
 | …
 | }
and, supposing that file is stored in the C:\PROJECT directory, the constraint in the script will look like:
 | PLUGIN_CONSTRAINT_on_ET C:\PROJECT\ANALYSIS.CLASS Num_tech_id_per_et 0 1


Integrate schemas

Integration of schemas

DB-MAIN allows to integrate a data schema into the current one. The current data schema (master schema) is the one displayed in the topmost window.

The menu command Assist/Integration/Schema first displays the list of the other data schemas included in the current project. The user must select the data schema that has to be integrated (the slave one) into the master schema. A file name is then requested to save a report of the integration. The integration process is executed after confirmation.

See also:

data schema integration rules and integrate objects.


Schema integration rules

Data schema integration rules

This section describes the rules used to integrate a slave data schema file into the current one (master schema).

Meta-properties, descriptions and graphical positions are always handled in the same way for all objects. The meta-properties defined in the slave data schema overwrite the master ones. The descriptions defined in the slave data schema are appended to the master ones. The graphical positions in the master data schema can be updated.

The creation date of the data schema is overwritten by the one found in the ISL file.

If the slave data schema is connected to another data schema, the connection is created if it does not exist for the master schema.

If the slave data schema contains an entity type not defined in the master, it is created. If an entity type already exists, the rules defined for two entity types that have the same name are applied.

If the slave data schema contains a rel-type not defined in the master, it is created. If a rel-type already exists, the rules defined for two rel-types that have the same name are applied.

If the slave data schema contains a collection not defined in the master, it is created. If a collection already exists, the rules defined for two collections that have the same name are applied.

Two entity types with the same name

The short name is not modified.

If there is an is-a relation in the slave schema, the connection to the cluster is created if it does not exist.

If the slave entity type has an attribute not defined in the master one, it is created. Otherwise, the rules defined for two attributes that have the same name are applied.

If the slave entity type contains a group not defined in the master one, it is created. Otherwise, the rules defined for two groups that have the same name are applied.

Two rel-types with the same name

The short name is not modified.

If the slave rel-type has an attribute not defined in the master one, it is created. Otherwise, the rules defined for two attributes that have the same name are applied.

If the slave rel-type has a role not defined in the master one, it is created. Otherwise, the rules defined for two roles that have the same name are applied.

If the slave rel-type contains a group not defined in the master one, it is created. Otherwise, the rules defined for two groups that have the same name are applied.

Two roles with the same name

The short name and the cardinality are not modified.

If the role is connected in the slave schema to an entity type to which it is not connected in the master schema, the connection is created.

Two attributes with the same name

The cardinality and the short name are not modified.

If the slave attribute is compound and the master one is atomic, the latter is deleted and replaced by the slave one. If the slave attribute is atomic and the master one is compound, the latter is not modified. If both attributes are compound (or both are atomic), the master is not modified.

If the slave attribute is compound and has an attribute not defined in the master one, it is created. Otherwise, the rules defined for two attributes that have the same name are applied.

If the slave attribute is compound and contains a group not defined in the master one, it is created. Otherwise, the rules defined for two groups that have the same name are applied.

Two groups with the same name

All group components in the slave schema that are not included in the master are added.

If the group is the origin of a constraint in the slave schema, this constraint is added and the master one (if there is) is deleted.

Two collections with the same name

The short name is not modified.

All entity types that were not in the collection are added to it.

See also:

Integrate schemas.


Integrate objects

Integration of objects

The Assist/Integration/Objects menu command allows to integrate two objects (entity types, rel-types or compound attributes) of the same data schema or between two different data schemas.

The user must first select an object that becomes the master object. (If there is no selection, only the Copy slave into master strategy is available.)

The Integrate two objects dialog box has the following features:

Type of integration | : | to select the type of integration : in the same data schema (ISS) or between two data schemas (IBS). ISS is the default option. If an object is selected in another schema than the master, IBS is selected.
Slave schema | : | to select the data schema containing the slave object (IBS only).
Type of slave object | : | to select the type (entity type, rel-type or compound attribute) of the slave object.
Master object | : | to change the name of the master object.
Slave object | : | to select the slave object.
Strategies | : | six strategies are possible for both kinds of object integration (ISS and IBS). They are described in the table below.
 | Integration in same schema | Integration between schemas
Copy slave into master (*) | to create the master object (if not empty) and transfer the chosen attributes, processing units, roles and is-a relations into it. If empty, the slave object is deleted. | to create the master object (if not empty) in the master schema with the chosen attributes and processing units.
Merge slave into master | to merge the slave object (attributes, processing units, roles and is-a relations) with the master object. If empty, the slave object is deleted. | to merge the slave object (attributes and processing units only) with the master object.
Create a 1-1 link (**) | to create a rel-type between the master and slave entity types. The cardinality of the new roles are [1-1] and [1-1] or [0-1] and [1-1]. | to copy the slave entity type and its attributes into the master schema and create a rel-type between Master and Slave. The cardinality of the new roles are [1-1] and [1-1] or [0-1] and [1-1].
Slave is-a master (**) | to create an is-a relation between the master and slave entity types. Master becomes the supertype. | to copy the slave entity type and its attributes into the master schema and create an is-a relation between Master and Slave. Master becomes the supertype.
Master is-a slave (**) | to create an is-a relation between the master and slave entity types. Slave becomes the supertype. | to copy the slave entity type and its attributes into the master schema and create an is-a relation between Master and Slave. Slave is the supertype.
Create common supertype (**) | to create a common supertype for the master and slave entity types. | to copy the slave entity type and its attributes into the master schema and create a common supertype for the master and slave entity types.

(*) only available for rel-types and entity types, and if no master is selected.

(**) only available for entity types.

Notes: | - The slave schema always remains unchanged when integrating between two schemas.
 | - Groups that contain transferred or copied attributes or roles are also transferred.
Rel-type name box | : | to give a name to the new rel-type (Create a 1-1 link strategy);
Cardinality box | : | to set the cardinality of the role played by the master entity type (Create a 1-1 link strategy);
Is-a Type box | : | to set the type of the is-a relation (nothing, D(isjoint), T(otal) or both disjoint and total (P(artition))) (Create a common supertype, Slave is a master and Master is a slave strategies);
Move | : | to move the selected items from the slave list box to the end of the master list box;
Same | : | to compare the selected items of both list boxes (see the second dialog box) and either delete the slave items or transfer them to the master list box;
Remove is-a redundancy | : | if checked, is-a redundancies are removed (Slave is a master and Master is a slave strategies). For example (Slave is a master strategy), if A is the master entity type, B is the slave one and (A,B) are sub-types of C, the is-a relation between B and C is deleted;
Swap Master with Slave | : | the master object becomes the slave one and conversely;
Help | : | to get help information on integration;
Apply | : | to execute integration using the selected strategy;
Reset | : | to reset the dialog box;
Close | : | to close the dialog box discarding changes.
The second dialog box compares two different components (attributes, processing units, roles or is-a relations) of the master and slave objects. It has the following features:
Master | : | to choose the master component. The slave component is removed from the slave list box;
Slave | : | to choose the slave component. The master component is removed from the master list box and the slave component is transferred to the master list box;
The comparison can be refined:
Name | : | to keep the name of the master or slave component;
Short | : | to keep the short name of the master or slave component (only for attributes and processing units);
Cardinality | : | to keep the cardinality of the master or slave component (only for attributes and roles);
Type | : | to keep the type of the master or slave attribute;
Semantic description | : | to keep the semantic description of the master and/or slave component(s);
Technical description | : | to keep the technical description of the master and/or slave component(s);

Help

:

to get help information on integration;

Ok | : | to accept the choices;
Cancel | : | to cancel comparison.


Load pattern

The Load pattern dialog box allows to load and edit pattern files. Patterns are split into two files (main and secondary patterns). The secondary patterns file contains the definitions of basic patterns that are used by other ones. Among others, this file contains the definition of spaces (mandatory or not) and variables in the target language. The main patterns file contains, among others, the definition of assignment and comparison.

For each pattern file, the Browse button allows to chose a file and the Edit button allows to edit the file. Both files are mandatory.

The Ok button launches the compilation of the patterns and closes the dialog box. If syntax errors are encountered, the dialog box is not closed.

The Cancel button closes the dialog box, discarding changes.

Patterns are expressed in a Pattern Definition Language (PDL) close to the BNF notation and including variables. Variables can be instantiated before or during the search. Forward definitions are not allowed, i.e. patterns used in the definition of other patterns must be defined before.

The syntax

<pattern>:
 | <pattern_name>::= <segment>*;
<segment>:
 | <terminal_seg>
 | | <pattern_name>
 | | <variable>
 | | <range>
 | | <optional_seg>
 | | <repeat_seg>
 | | <group_seg>
 | | <choice_seg>
 | | <regular_expr>
<variable>:
 | @<pattern_name>
The '@' symbol indicates that the following segment is a variable. If a variable appears twice in a pattern, then both occurrences have the same value. When a pattern is found, the value of the variables can be known. A variable cannot appear in repetitive structures.
<range>:
 | range(c1-c2)
Any character between c1 and c2. c1 and c2 are two characters.
<optional_seg>:
 | [<segment>]
Optional segment
<repeat_seg>:
 | <segment>*
Repetitive segment: matches <segment> one or more times
<group_seg>:
 | (<segment>*)
<choice_seg>:
 | {<segment> | ... | <segment>}
Matches any of the <segment> elements.
<regular_exp>:
 | /g"<regular expression>"
<regular expression> is a regular expression à la grep. Such expressions can contain the following characters:

          •

    . matches any single character;

  • * matches 0, 1 or several copies of the preceding expression;

  • + matches 1 or several copies of the preceding expression;

  • [...] matches any character listed between the square brackets, e.g. [0,1,2] means 0 or 1 or 2;

  • [x-y] specifies a character range, e.g., [0-4] means [0,1,2,3,4];

  • ? matches 0 or 1 occurrence of the previous expression;

  • "..." matches exactly the content between quotes;

  • /t matches a tabulation;

  • /r/n matches the newline characters (carriage return + newline).

    <terminal_seg>:
 | "string"
Matches the string (case sensitive), /t = tabulation, /n = new line.
<pattern_name>:
 | [A-Za-z0-9][A-Za-z0-9]0-29
The name of the pattern.


Search

The Assist/Text analysis/Search function is used to search a text for a pattern. The search scope depends on the current window:

- | If the current window is a schema, the search scope includes the names and/or descriptions of the displayed objects (depending on the state of Name, Sem and Tech check boxes in the Search dialog box). The next matching object becomes the current one.
- | If the current window is a source text browser, the search scope is the whole source text. The next line in which the pattern is found is highlighted and becomes the current one.
The Search dialog box items has the following features:
Pattern | : | to select the pattern to search for; the definition of the selected pattern is displayed in the text field. If the combo box is empty, the Assist/Text analysis/ Load pattern command must be used first to load the patterns. If the selected pattern contains variables, they are displayed in the list box below the Value text field.
Value + Change | : | to instantiate variables (to give them a value) before the search process; otherwise, they can be instantiated during the search: when a pattern is found and the search dialog box reopened, the variables are instantiated.
Clear | : | to clear the value (if any) of the selected variable.
Clear all | : | to clear the values of all variables.
Name, Sem and Tech | : | to select which kind(s) of text objects must be included in the search scope (only for schemas).
Case sensitive | : | if checked, the search is case sensitive.
Select all | : | if checked, all the lines or objects that contain the pattern are selected; otherwise, only the next one is selected.
Help | : | to get help information on the purpose;
Ok | : | to close the dialog box and launch the search using the chosen options;
Cancel | : | to close the dialog box without executing any action;
The Assist/Text analysis/Search next (or <F3> key) is used to find the next occurrence of the pattern using the same options.


Procedure linked to pattern

Procedure linked to a pattern

The Assist/Text analysis/Execute function is used to search a text for a pattern (with variables). When this pattern is found, the variables instances become the parameters of a Voyager 2 procedure. The search scope depends on the current window:

-

If the current window is a schema, the search scope includes the descriptions of the displayed objects (depending on the state of Sem and Tech check boxes in the Search dialog box). The next matching object becomes the current one. The search starts at the current object.

-

If the current window is a source text browser, the search scope is the source text part starting at the current line. The next line in which the pattern is found is highlighted and becomes the current one.

There are three pseudo-variables (file name, line num and pattern). They contain respectively the name of the searched file (only for a source text browser), the line number of the line that contains the first character of the pattern (only for a source text browser) and the instantiated pattern. Those variables can be instantiated before the search process or during it.

The Procedure linked to a pattern dialog box has the following features:

Pattern

:

to select the pattern to search for; the definition of the selected pattern is displayed in the text field; if the combo box is empty, the Assist/Text analysis/ Load pattern command must be used first to load the patterns. If the selected pattern contains variables, they are displayed in the list box below the Value text field;

Value + Change

:

to instantiate variables (to give them a value) before the search process; otherwise, they can be instantiated during the search;

Clear

:

to clear the value (if any) of the selected variable;

Clear all

:

to clear the values of all variables;

Sem and Tech

:

to select which kind(s) of text objects must be included in the search scope (only for schemas);

Case sensitive

:

if checked, the search is case sensitive;

Java/Voyager 2 program

:

to select the appropriate .class or .oxo file (using the Browse button);

Procedure

:

to give the name of the procedure (can be selected in the dropdown list for Voyager 2 programs);

First, Next and Remove

:

to list which instantiated variables should become the procedure parameters;

Help

:

to get help information on the purpose;

Ok

:

to close the dialog box and launch the search using the chosen options;

Cancel

:

to close the dialog box without executing any action.

The Java method must be declared public static in a .class file, its parameters must be strings and must be in the same order as the variabled in the list box. For example:

import java.lang.String;
import …;

public class TextAnalysis
{

…

public static void lnk_proc(String s1, String s2)
{

…

}

…

}

The Voyager 2 procedure must be declared exportable, its parameters must be strings and be in the same order as the variables in the list box. The main program is not executed, so it can be empty. For example:

export lnk_proc(string : var_1, string : var_2)

{

...

}

begin

end


Dependency graph

The dependency graph is a graph in which nodes are variables of the analyzed program and edges represent relationships between variables defined by statements (such as assignments, comparisons, etc.).

The statements that define relationships between variables are specified by patterns containing the two variables var_1 and var_2.

Three steps should be followed to use the dependency graph:

 | Choose the display settings.
 | Compute the dependency graph.
 | Visualize the graph: click in the source text with the right button on the name of a variable to color all the variables that are connected to it in the dependency graph. Use the <tab> key to go from one colored variable to the next one.
Configuration tip
By default, when you click with the right mouse button on the name of a variable, it is colored only if it is connected to another one in the dependency graph. To color a variable even if it is not in the dependency graph, call the File/Configuration /…Dependency graph command and uncheck the "Only the variables of the dependency graph can be colored" check box.
See also : Source Window, Load Pattern, Configuration


Compute dependency graph

Compute the dependency graph

The Dependency dialog box is used to compute the dependency graph. It has the following features:

Pattern | : | to select the patterns that define the relationships between variables;
Add | : | to add the selected pattern to the list; this pattern must have the two variables var_1 and var_2;
Delete | : | to remove a pattern from the list;
Directed | : | if checked, the next added pattern will be oriented, i.e. there will be an oriented edge from var_1 to var_2;
Separator | : | to select the pattern used to find the beginning and the end of a variable.
Case sensitive | : | if checked, the search is case sensitive;
Save dependency graph | : | if checked, the dependency graph is saved to a file. The saved file includes two versions of the graph: the first one contains the relations found using the patterns and the second one contains the transitive closure of the first one;
 |  | The two graphs are separated by a line (“****”) and stored in a textual format:

<variable> : <list of variables directly reachable from the variable>

Help | : | to get help information on the purpose;
Ok | : | to close the dialog box and compute the dependency graph;
Cancel | : | to close the dialog box without executing any action.


Program slicing

The slice (of a program) associated to a point p and a variable x consists of all statements and predicates of the program that might affect the value of x at point p.

In DB-MAIN, the program slicing computes the slice that might affect the value of any of the variables referenced at a given point of the program.

To compute a program slice, select a line of the program in the source file window and use the command Assist/Text analysis/Program slicing. A console displays information on the text parsing and the slice computation. If the selected line contains more than one instruction, you are asked to choose among them. Then the list of variables referenced by the instruction is displayed. Select the variables for which the slice must be computed. When the process is finished, close the console (Exit button). The lines of the slice are now colored.

Keyboard actions

<N> | to select the next line of the slice;
<P> | to select the previous line of the slice.
See also : Text analysis settings


Slicing assistant

The program slicing assistant allows to automate the computation of several slices on the same source code. The intersection or union of those slices can be colored.

The dialog box is divided into four parts:

          •

    Start: to select the type of lines on which slices must be computed (current lines, marked lines, lines containing a type of instruction, lines containing a given variable).

  • Condition: to give a condition that the slice must verify to be displayed (no condition or the slice must contain a type of instruction).

  • Action: to select the action to perform on the computed slices (color the union or intersection of slices; display in the console the lines computed and those that match the condition; display in the console the variables that are referenced in slices).

  • Slice type: to choose the type of slice that must be computed (backward or forward). If Only dataflow is checked, the slice only takes into account the data flow information and does not take care of the control flow one.


Text analysis setting

Text analysis settings

The Text analysis settings dialog box allows to set some configuration options. It has the following features:

Color (Dependency graph) | : | to change the color used to color the dependency graph;
Color (Program slicing) | : | to change the color used to color program slices;
Copy line number | : | if checked, when lines are copied to the clipboard, they are prefixed with their line number;
Help | : | to get help information on the purpose;
Ok | : | to close the dialog box saving changes;
Cancel | : | to close the dialog box discarding changes.


Goto

If some schema objects were created from a COBOL DDL source text browser, this function allows to highlight the corresponding object or source text line:

If the active window is a schema, the Goto command highlights the source text line that was used to create the current object.

If the active window is a source text browser, the Goto command highlights the object that was created or modified by the current line of the source text.


Reference key finding assitant

Reference key finding

The Reference key finding assistant proposes some popular heuristics to find and create foreign keys.

The analyst gives a list of groups and chooses one of the following strategies:

given a candidate foreign key (in the group list), find the possible target groups;

given a group (usually an identifier displayed in the group list), find the fields (an existing group or an attribute) of the schema that could reference this group.

Depending on the chosen strategy, the analyst gives the criteria to find the matching groups. When the matching groups are found, he can create the foreign keys.

The Reference key finding assistant can be accessed through the Assist/Referential key menu command.

A first dialog displays in its top part the chosen strategy.

On the left, the analyst can choose the kind of groups that are used as the origin or the target of the FK (depending on the chosen strategy). This list is called "selected groups", it can contain the selected or marked groups of the schema, all primary identifiers, all identifiers, all groups, or the groups selected by a Voyager 2 function.

The entity type, attribute list and selected groups are displayed in the bottom part of the dialog box if the first strategy is chosen, and in the top part otherwise. The other part of the dialog box displays the groups that match the search criteria (if it is the first call to the assistant no matching groups are displayed). The list of matching groups and attributes, prefixed by the name of their entity type, are displayed in a combo box. The components of an existing group are surrounded by curly brackets. An attribute that does not take part in any group is diplayed whit its full name. If a group is followed by a "*" then it is already the origin of a reference key and a second group cannot be created. The user can decide whether to show or not the attributes of the origin and target entity types by checking or not the Show attributes box.

The search criteria can be changed by clicking on the Search button (see the search criteria section below). The Reset button allows to set default values to the search criteria. The default values are the following: no constraint on the target group type, components of corresponding groups must have the same type and length, attributes are not accepted, multivalued reference keys are not accepted, no name matching rules specified (see the search criteria description).

If the matching rules find a group that is not the origin or target of a FK, the Remove button allows to remove it from the list. The Clear button allows to obtain the complete list of matching groups again.

The checkbox list on the right side of the dialog box allows to select the type of constraint that must be created. In the current version, only ref (referential constraint) and ref equ (equality constraint) are available.

The Create button allows to create a foreign key between the selected group and the matching group that is displayed in the combo box. The Create all button allows to create foreign keys between all "selected groups" and all matching groups.

The Advanced button is used to create foreign keys between all selected groups and matching groups with the help of a Voyager 2 procedure. A new dialog box appears, asking for a Voyager 2 program and two Voyager 2 procedures: one to create foreign keys between two groups and the other to create foreign keys between an attribute and a group. These Voyager 2 procedures must have the following signature.

export procedure <proc_name>(group: <origin_gr>, group: <target_gr>, integer: <t>)

where

<origin_gr> is the origin group of the foreign key

<target_gr> is the target group of the foreign key

<t> is the type of the foreign key

and

export procedure <proc_name>(attribute: <origin_att>, group: <target_gr>, integer: <t>)

where

<origin_att> is the origin attribute of the foreign key

<target_gr> is the target group of the foreign key

<t> is the type of the foreign key

These procedures are executed for each matching group. The Browse button is used to select the .oxo file containing both procedures. The latter are then selected in the other combo box.

The Goto button (on the right of the target and origin entity types) allows to display the associated entity type in the middle of the schema window.

To change the selected groups, select other groups in the schema window without closing the assistant. Then re-activate the reference key assistant. Selected groups and matching groups are thus refreshed, using the previously set criteria.

The Search criteria dialog box

The Search button in the Reference key finding assistant dialog box opens the Search criteria dialog box.

Depending of the chosen strategy, some items are disabled in this dialog box. The various criteria are described below.

 | Skip existing reference key: to avoid selecting groups that already represent the origin of a reference constraint.
 | Accept attribute (only when using the second strategy): if the selected group contains only one attribute, this option allows to extend the search scope to attributes that are not members of a group and that verify all the other matching rules.
 | Accept multivalued reference key (only when using the second strategy): to accept groups that contain a multivalued attribute.
 | Choose the type of target group (only when using the first strategy): to choose the type of the target group (primary identifier, any identifier or any group (no constraint on the group type)).
 | Structure matching rules:
 | Same total length: if checked, the two groups must be the same length;
 | Same length: if checked, all corresponding group components must be the same length;
 | Same type: if checked, all corresponding group components must be the same type;
 | Hierarchical: if checked (Some total length is then automatically checked as well) and if a group contains a role, the length of the group is the length of its attributes plus the length of the primary identifier of the entity type connected by the role (if the role is multi-ET, the longest primary identifier is taken into account);
 | If nothing is checked, there are no constraints on the structure.
 | Name matching rules (only when using the second strategy): this rule contains three criteria dealing with the names of attributes. If this rule is used, the origin group can contain only one attribute.
 | Key word: the origin attribute must contain a key word. If this rule is used, the two other name matching rules are applied on the attribute name without the key word.
 | Some or all the characters of the target entity type name must be included in the origin attribute name.
 | Some or all the characters of the target attribute name must be included in the origin attribute name.
 | For the last two rules, if all is selected, all the characters must be included and must be contiguous; if a number is selected (i) then the first i characters of the target entity type or attribute name must be included in the origin attribute, but not necessarily in a contiguous way. For example: the three first characters of ABCD are included into FABCDE and in AFBCE but not in CBADE.
 | Help : to get help information on the purpose;
 | More…: the user can execute two Voyager 2 functions: one that checks if two groups match and another that checks if an attribute matches the target group. These Voyager 2 procedures must have the following signature:
export function integer <match_group>(group: <origin_gr>, group: <target_gr>)
export function integer <match_att_group>(attribute: <origin_att>, group: <target_gr>)

OK: to close the dialog box saving changes;

Cancel: to close the dialog box discarding changes.


Generation

Code generation (File/Generate/...)

SQL Generation

This function allows to translate a DB-MAIN data schema into an executable SQL text according to a selected DBMS (Access, Interbase, MySQL, PostgreSQL, standard SQL, academic SQL). The source schema must be compliant with the selected DBMS.

Academic SQL: | aesthetic presentation of foreign keys in create table statements, possible forward references.
Standard SQL: | compilable code without forward references. Only primary and foreign key constraints are expressed.
Access: | takes into account some specific aspects of this DBMS (create database, names,…). To use the generated file in Access, you must open the file SQL-“Script-Interpreter.mdb” (for Microsoft Office 2000 and higher; “SQL-Script-Interpreter-97.mdb” for Microsoft Office 97) in the DB-MAIN directory. Choose “Forms” and open “Execute SQL script”. The “Search Script” button loads the generated file and the “Run Script” button creates the SQL structures in Access.
Interbase: | takes into account some specific aspects of this DBMS (create database, comments,…).
MySQL: | takes into account some specific aspects of this DBMS (create database, checks,…).
PostgreSQL: | takes into account some specific aspects of this DBMS (create database, checks,…).
Parametric SQL generator: | takes into account some specific aspects of the Oracle DBMS. The user has several choices for the representation of constraints (primary identifier, foreign keys, …). This Voyager 2 program uses the physical information (stored into meta-properties) generated by the relational physical design assistant.
Note: The DB-MAIN Education version only provides the Standard SQL, Access, Interbase, MySQL and PostgreSQL generators.

See also:

SQL DDL code generation.

COBOL generation

This function allows to translate a DB-MAIN data schema into COBOL files (Environment and Data sections). The source schema must be compliant with the target DBMS. The COBOL generator is a Voyager 2 program. Before first use, the path to the appropriate *.oxo file must be set in the configuration dialog box. (File/Configuration… Code generators).

Note: this generator is not available in the Education version.

See also:

COBOL DDL code generation.

CODASYL generation

This function allows to translate a DB-MAIN data schema into a CODASYL program (schema and sub-schemas). The source schema must be compliant with the target DBMS. There are two versions of this generator, both written in Voyager 2: a CODASYL generator (codasyl.oxo) and an IDS/II generator (ids2.oxo). Before first use, the path to the appropriate *.oxo file must be set in the configuration dialog box. (File/Configuration…Code generators).

Note: this generator is not available in the Education version.

See also:

CODASYL IDS/II DDL code generation, CODASYL BTBG71 DDL code generation.

XML DTD generation

This function allows to translate a DB-MAIN data schema into an XML DTD file. The DTD generator is a Voyager 2 program. Before first use, the path to the appropriate *.oxo file must be set in the configuration dialog box (File/Configuration…Code generators).

See also:

XML DTD code generation.


CODASYL BTBG71 DDL code generation

CODASYL BTBG71 DDL code generation: reference manual

Introduction

This section describes what a CODASYL BTBG71 (referred to as CODASYL in the rest of the text) compliant schema is and how the generator translates such schemas into CODASYL DDL code. After that the choices made during CODASYL code generation are detailed.

CODASYL compliant schemas

A CODASYL compliant schema is composed of entity types, relationship types and collections. Each collection contains one or several entity types. An entity type may appear in more than one collection.

Entity types may have attributes. These can be mandatory or optional, single-valued or multivalued, atomic or compound.

Relationship types must be functional and non-recursive. They must have one mono-entity type role (called owner), the cardinality of which is [0-N] and another role (called member), the cardinality of which is [0-1] or [1-1]. The member role can be multi-entity type.

The identifier of an entity type may be composed either of one or several single-valued attributes (type 1 identifier) or of one or several single-valued attributes and a role (type 2 identifier). Each entity type may have at most one type 1 identifier and as many type 2 identifiers as there are distinct roles played by this entity type.

The schema can contain a special entity type called system. This entity type cannot have attributes and cannot play member roles.

There are no other integrity constraints in CODASYL compliant schemas.

Translation of CODASYL compliant schemas

The generation of CODASYL BTBG71 DDL code from a CODASYL compliant schema is performed in several steps:

First, the name of the schema is used to create the “ schema name ” entry as follows:

schema name is schema_name.

where schema_name is the name of the source schema.

Then, collections and entity types are used to declare areas. Each collection and some entity types are translated into areas as follows (the selection of entity types for this process is explained in the next section):

area name is area_name.

where area_name is the name of the source object (collection or entity type).

Record types are included during the next step, each one of them corresponds to an entity type and is described by a sequence of lines.

The “record name” entry takes the name of the entity type. If it has a type 1 identifier or an access key composed of attributes only, it is added as a “location mode” entry. Otherwise the location mode is left to the SGBD assessment. Then, all the areas to which the entity type belongs are listed in the “ within ” entry. If there is more than one area of this kind, an area-id entry is added (the rules used to compute its name are described in the next section). Then, data items (corresponding to attributes) are added. The picture of a data item is derived from the type and length of the corresponding attribute (the conversion rules are explained in the next section). “ Record type ” entries are built as follows:

record name is record_name;

[location mode is calc using calc_key duplicates duplication;]

within area_name[, area_name,.., area_name area-id is area-id];

2 data_item; picture picture[; occurs times times].

2 data_item[; occurs times times].

 |  | 3 data_item; picture picture[; occurs times times].
 | ...
where

          •

    record_name is the name of the corresponding entity type;

     | calc_key is the name of the type 1 identifier of the entity type or the name of an access key composed of attributes only;
 | duplication is “not allowed” if calc_key is an identifier and “allowed” otherwise;
 | area_name is the name of an area containing the entity type;
 | area-id is the name given to the set of areas containing the entity type;
 | data_item is the name of an attribute of the entity type;
 | picture is the picture derived from the type and length of this attribute;
 | times is the maximum cardinality of the attribute (if it is 'N', times is set to 30).
The location mode (enclosed between square brackets) is added only if a calc_key is defined for this entity type. The area-id entry is added only if there is more than one area containing the entity type.
The occurs clause is added if the corresponding attribute is multivalued.
Finally, relationship types are used to declare set types:
set name is set_name;
     | order is last;
 | owner is owner_name.
where set_name is the name of the set type (the rules used to compute this name are explained in the next section) and owner_name is the name of the entity type that plays the owner role in the relationship type. This entity type is called owner of the set type.
The entity types that play member roles are then added. These are called members of the set type. Each member is described as follows:
member is member_name mandatory insertion;
[duplicates not allowed for key_name;]
set occurrence selection thru current of set.
where member_name is the name of the member, insertion is “automatic” if the cardinality of the role played by the member is [1-1] and “manual” if it is [0-1], and key_name is the list of the attributes that form (together with the member role) a type 2 identifier of this entity type. Again, the square brackets indicate that it is optional.

    Choices made during translation

    Various choices are made during the translation process. First, we will describe the objects that are used to create areas. Next, we will see how the generator builds area-ids and set names. Then, we will explain how the generator computes the names of set types. Finally, we will list the mappings between the type and length of attributes and the picture of corresponding data items.

    Areas

    An area corresponds to either a collection or an entity type. The generator handles collections first: each of them is translated into an area. After this, each entity type that is not included in a collection is translated into an area too. This avoids declaring collections containing only one entity type. This rule allows only one exception: the “system” entity type is translated neither into an area nor into a record type.

    Unlike other concepts, the concept of area does not come from a direct translation. It comes from collections and entity types together.

    Area-ids

    The name of an area-id is the concatenation of the character 'A' (standing for 'area') and the name of the entity type that belongs to the listed areas.

    Set names

    The set name is the name of the corresponding relationship type. “-A” is added at the end of it if this name is already used for another set type (in case of one-to-one relationship types).

    Pictures of data items

    The following table lists the mappings between the type and length of attributes and the picture of data items.

    Type and length of attribute | Field picture
CHAR(l) | picture "X(l)"
VARCHAR(l) | picture "X(l)"
NUMERIC(l,0) | type is decimal l
NUMERIC(l,d) | type is decimal l,d
FLOAT(l) | picture "9(l)"
DATE | picture "99/99/9999"
BOOLEAN | picture "X"

    Compound attributes are translated into compound data items: the attribute itself is added at its level, its components are added at the next level, and so forth.


CODASYL IDS/II DDL code generation

CODASYL IDS/II (BULL DPS 7 IDS/II GCOS 7 release V5) DDL code generation: reference manual

Introduction

This section describes what a CODASYL IDS/II (referred to as IDS/II in the rest of the text) compliant schema is and how the generator translates such schemas into IDS/II DDL code. After that the choices made during IDS/II code generation are detailed.

IDS/II compliant schemas

An IDS/II compliant schema is composed of entity types, relationship types and collections. Each collection contains one or several entity types. An entity type may appear in more than one collection.

Entity types may have attributes. These can be mandatory or optional, single-valued or multivalued, atomic or compound.

Relationship types must be functional and non-recursive. They must have one mono-entity type role (called owner), the cardinality of which is [0-N] and another role (called member), the cardinality of which is [0-1] or [1-1]. The member role can be multi-entity type.

The identifier of an entity type may be composed either of one or several single-valued attributes (type 1 identifier) or of one or several single-valued attributes and a role (type 2 identifier). Each entity type may have at most one type 1 identifier and as many type 2 identifiers as there are distinct roles played by this entity type.

There are no other integrity constraints in IDS/II compliant schemas.

Translation of IDS/II compliant schemas

The generation of IDS/II DDL code from a IDS/II compliant schema is performed in several steps:

First, the name of the schema is used to create the “SCHEMA NAME” entry as follows:

SCHEMA NAME IS schema_name.

where schema_name is the name of the source schema.

Then, collections and entity types are used to declare areas. Each collection and some entity types are translated into areas as follows (the selection of entity types for this process is explained in the next section):

AREA NAME IS area_name.

where area_name is the name of the source object (collection or entity type).

Record types are included during the next step, each one of them corresponds to an entity type and is described by a sequence of lines.

The “record name” entry takes the name of the entity type. If it has a type 1 identifier or an access key composed of attributes only, it is added as a “location mode” entry. If the entity type has no type 1 identifier, the location mode is “direct”. Then, all the areas to which the entity type belongs are listed in the “ within ” entry. If there is more than one area of this kind, an area-id entry is added (the rules used to compute its name are described in the next section). Then, data items (corresponding to attributes) are added. The picture of a data item is derived from the type and length of the corresponding attribute (the conversion rules are explained in the next section). “ Record type ” entries are built as follows:

RECORD NAME IS record_name.

LOCATION MODE IS CALC USING calc_key

DUPLICATES duplication

WITHIN area_name[, area_name,.., area_name AREA-ID IS area-id];

02 data_item TYPE IS picture.

02 data_item .

 |  | 03 data_item TYPE IS picture.
 | ...
or
RECORD NAME IS record_name.

LOCATION MODE IS DIRECT DUMMY

WITHIN area_name[, area_name,.., area_name AREA-ID IS area-id];

02 data_item TYPE IS picture.

02 data_item .

03 data_item TYPE IS picture.

...

where

  • record_name is the name of the corresponding entity type;

     | calc_key is the name of the type 1 identifier of the entity type or the name of an access key composed of attributes only;
 | duplication is “not allowed” if calc_key is an identifier and “allowed” otherwise;
 | area_name is the name of an area containing the entity type;
 | area-id is the name given to the set of areas containing the entity type;
 | data_item is the name of an attribute of the entity type;
 | picture is the picture derived from the type and length of this attribute.
The area-id entry is added only if there is more than one area containing the entity type.
The location mode is “calc” if a calc_key is defined for this entity type and “direct” otherwise. The generator will take the first group of lines in the first case and the second one in the second case.
Finally, relationship types are used to declare set types:
SET NAME IS set_name
     | OWNER IS owner_name
 | ORDER IS PERMANENT LAST.
where set_name is the name of the set type (the rules used to compute this name are explained in the next section) and owner_name is the name of the entity type that plays the owner role in the relationship type. This entity type is called owner of the set type.
The entity types that play member roles are then added. These are called members of the set type. Each member is described as follows:
MEMBER IS member_name
 | INSERTION insertion RETENTION MANDATORY
 | [DUPLICATES NOT ALLOWED FOR key_name]
 | SET SELECTION IS THRU set_name BY APPLICATION.
where member_name is the name of the member, insertion is “automatic” if the cardinality of the role played by the member is [1-1] and “manual” if it is [0-1], and key_name is the list of the attributes that form (together with the member role) a type 2 identifier of this entity type. Again, the square brackets indicate that it is optional.

    Choices made during translation

    Various choices are made during the translation process. First, we will describe the objects that are used to create areas. Next, we will see how the generator builds area-ids and set names. Then, we will explain how the generator computes the names of set types. Finally, we will list the mappings between the type and length of attributes and the picture of corresponding data items.

    Areas

    An area corresponds to either a collection or an entity type. The generator handles collections first: each of them is translated into an area. After this, each entity type that is not included in a collection is translated into an area too. This avoids declaring collections containing only one entity type.

    Unlike other concepts, the concept of area does not come from a direct translation. It comes from collections and entity types together.

    Area-ids

    The name of an area-id is the concatenation of the character 'A' (standing for 'area') and the name of the entity type that belongs to the listed areas.

    Set names

    The set name is the name of the corresponding relationship type. “-A” is added at the end of it if this name is already used for another set type (in case of one-to-one relationship types).

    Pictures of data items

    The following table lists the mappings between the type and length of attributes and the picture of data items.

    Type and length of attribute | Field picture
CHAR(l) | CHARACTER l
VARCHAR(l) | CHARACTER l
NUMERIC(l,0) | DECIMAL l
NUMERIC(l,d) | DECIMAL l,d
FLOAT(l) | DECIMAL l
DATE | CHARACTER 10
BOOLEAN | CHARACTER

    Compound attributes are translated into compound data items: the attribute itself is added at its level, its components are added at the next level, and so forth.


COBOL DDL code generation

COBOL DDL code generation: reference manual

Introduction

This section describes what a COBOL compliant schema is and how the generator translates such schemas into COBOL DDL code. After that the choices made during COBOL code generation are detailed.

COBOL compliant schemas

A COBOL compliant schema is composed of entity types and collections. Each collection contains one or several entity types. An entity type appears in one collection at most.

Entity types have at least one attribute. Attributes are always mandatory, they can be single-valued or multivalued, atomic or compound.

Relationship types are not allowed in COBOL compliant schemas.

The identifier of an entity type must be composed of one and only one single-valued attribute. It may be compound (e.g. if the identifier is initially composed of more than one attribute).

There are no other integrity constraints in COBOL compliant schemas.

Translation of a COBOL compliant schema

The generation of COBOL DDL code from a COBOL compliant schema is performed in several steps:

First, the schema name is used to create the “PROGRAM-ID” entry in the “IDENTIFICATION DIVISION” as follows:

IDENTIFICATION DIVISION.

PROGRAM-ID. schema_name.

where schema_name is the name of the source schema.

Then, collections and entity types are used to build the “FILE-CONTROL” part of the “INPUT-OUTPUT SECTION” in the ENVIRONMENT DIVISION:

ENVIRONMENT DIVISION.

INPUT-OUTPUT SECTION.

FILE-CONTROL.

Each collection and some entity types are translated into COBOL files as follows (the selection of entity types for this process is explained in the next section):

SELECT file_name ASSIGN TO "file_name"

ORGANIZATION IS INDEXED

ACCESS MODE IS DYNAMIC

RECORD KEY IS record_key.

or

SELECT file_name ASSIGN TO "file_name"

ORGANIZATION IS SEQUENTIAL

ACCESS MODE IS SEQUENTIAL.

where file_name is the name of the source object (collection or entity type) and record_key is the name of the identifier of an entity type included in the collection (translation of a collection) or the name of the entity type identifier (translation of an entity type).

The first group of lines is used if at least one entity type of the collection (or the entity type itself) has an identifier, (the rules used to choose the record_key among all candidates are explained in the next section). Otherwise, the second group of lines is used.

Finally, entity types are described in the “FILE SECTION” of the “DATA DIVISION”:

DATA DIVISION.

FILE SECTION.

FD entries take up file names (see above). Each entity type contained in a file is described in the corresponding FD entry as a COBOL record type. The first level indicates the name of the record type (i.e. the name of the source entity type). The next one contains the description of its fields (corresponding to source attributes). The picture of the field is derived from the type and length of the corresponding attribute (the mapping rules are described in the next section). FD entries are built as follows:

FD file_name.

01 record_name.

02 field_name picture.

02 field_name [OCCURS times TIMES].

03 field_name picture.

...

01 record_name.

02 field_name picture.

...

where record_name is the name of the corresponding entity type, field_name is the name of the corresponding attribute, picture is the picture derived from the type and length of this attribute and times is its maximum cardinality (if it is 'N', times is set to 30).

Choices made during translation

Various choices are made during the translation process. First, we will describe the objects that are used to create COBOL files. Next, we will see how the generator chooses record keys. Finally, we will list the mappings between the type and length of attributes and the picture of the corresponding fields.

Before going further, let us note that the names added to the COBOL code are not checked. If a name is not compliant with the COBOL syntax, it is not detected.

COBOL files

A COBOL file corresponds to either a collection or an entity type. The generator handles collections first: each of them is translated into a COBOL file. After this, each entity type that is not included in a collection is translated into a COBOL file too. This avoids declaring collections containing only one entity type.

Unlike other concepts, the concept of COBOL file does not come from a direct translation. It comes from collections and entity types together.

Record keys

The concept of record key in COBOL is quite strange: it is a unique key that identifies a record inside a COBOL file. However, a COBOL file may contain more than one record type (see above), so each record type of the file must have an identifier of the same physical length as the record key of the file. This length is impossible to compute, because it depends on the computer used (e.g. an integer may be coded on 6 or 8 bytes).

Consequently a choice must be done for the record key. The generator looks for an entity type, belonging to the COBOL file, that has an identifier. If there is, this identifier becomes the record key. Otherwise, the file is declared SEQUENTIAL and no record key is associated to it.

This choice is possibly not the best one. But the database designer is responsible for choosing a good organization of entity types into collections, i.e. an organization that takes care of this problem...

Field pictures

The following table lists the mappings between the type and length of attributes and the picture of data items.

Type and length of attribute | Field picture
CHAR(l) | PIC X(l)
VARCHAR(l) | PIC X(l)
NUMERIC(l,0) | PIC 9(l)
NUMERIC(l,d) | PIC 9(l-d)V9(d)
FLOAT(l) | PIC 9(l)
DATE | PIC 99/99/9999
BOOLEAN | PIC X

Compound attributes are translated into compound fields: the attribute itself is added at its level, its components are added at the next level, and so forth.


SQL DDL code generation

SQL DDL code generation: reference manual

To be written…


XML

XML DTD code generation: reference manual

Introduction

This section describes what an XML compliant schema is and how the generator translates such schemas into XML DTD files.

Only XML compliant schemas can be handled by the generator. The Schema analysis assistant (Menu Assist/Schema Analysis/Predefined/ XML) includes a predefined script named “XML” that allows to verify the compliance of a schema with the XML model.

XML compliant schemas

An XML compliant schema is composed of entity types and relationship types. Neither collections nor ISA relations are allowed.

Constraints on relationship types :

Vocabulary :

Every relationship type must have a role named "f" (standing for "father"). This role is said to be the father role and links the father entity type to the relationship type. The other role can have any name or no name at all. It is said to be the child role and links the child entity type to the relationship type. An entity type playing the child role of a relationship type is a child of the entity type playing the father role of the same relationship type. Attributes named “#pcdata” and “#any” are children of the entity type in which they are defined.

Relationship types must be binary. Neither attributes nor groups are allowed in relationship types.

Roles must be mono-ET.

The cardinality of a father role can be [0-1], [1-1], [0-N] or [1-N].

The cardinality of a child role is always[1-1].

Constraints on entity types :

Vocabulary :

Entity types associated with the “tech” stereotype are called technical entity types. Other ones are, not surprisingly, non-technical entity types.

An non-technical entity type that plays one or several father roles and no child roles is called a root. In other words, a root is an entity type that has no father.

An XML compliant schema has one and only one root.

In an XML compliant schema, the names of non-technical entity types must comply with specific rules (cfr. XML naming rules).

In an entity type,

-

the only groups allowed are those submitted to a user-defined constraint named "choice", "seq", "gid" or "idref";

-

at most one group submitted to the "gid" user-defined constraint is allowed;

-

at most one technical attribute (named "#pcdata" or "#any") is allowed;

-

if a "#any" attribute is defined, the entity type cannot have other children;

-

only atomic attributes are allowed.

-

If an entity type has at least two children, it must contain one and only one group composed of all the children of this entity type; this group is submitted to a "choice" or "seq" user-defined constraint.

-

If an entity type has at most one child, groups submitted to a "choice" or "seq" user-defined constraint are not allowed.

Constraints on attributes :

Vocabulary :

Attributes named "#pcdata" or "#any" are called technical attributes.

Every attribute must verify one and only one of the following conditions:

-

its name is "#pcdata" and it is a component of at most one group submitted to a "choice" or "seq" user-defined constraint. This group has at least two components.

-

its name is "#any" and it does not take part in any group.

-

its type is varchar, its maximum cardinality is 1 and it is the unique component of a group submitted to the "gid" user-defined constraint.

-

its type is varchar, its maximum cardinality is 1 or N and it is the unique component of a group submitted to the "idref" user-defined constraint.

-

its type is the user-defined "cdata" type, its maximum cardinality is 1 and it does not take part in any group.

-

its type is the user-defined "enum" type, its maximum cardinality is 1, it does not take part in any group and its "Enum" meta-property has at least one value.

-

its type is the user-defined "notation" type, its maximum cardinality is 1 or N, it does not take part in any group and its "Notation" meta-property has at least one value.

-

its type is the user-defined "entity" type, its maximum cardinality is 1 or N, it does not take part in any group and its "Entity" meta-property has at least one value.

-

its type is the user-defined "nmtoken" type, its maximum cardinality is 1 or N and it does not take part in any group.

Attribute names other than « #pcdata » or « #any » must comply with specific rules (cfr. XML naming rules).

XML naming rules :

The names of attributes (except for « #pcdata » and « #any » attributes) and non-technical entity types must comply with the following rules:

-

the first character must be a letter, an underscore (_) or a colon (:);

-

other characters must be letters, digits, underscores (_), dots (.), dashes (-) or colons (:).

These rules comply with the XML language specifications because attributes and non-technical entity types will be translated into XML attributes and element types.

Translation of XML compliant schemas

Only XML compliant schemas can be processed by the DTD file generator.

The name of the generated DTD file is the concatenation of the schema name and the *.dtd extension.

DTD file generation is a three-step process: entity declaration, notation declaration and element type and attribute-list declaration.

Entity declaration

The 'Entity' meta-property linked to the schema is a list containing several complete entity declarations. Each one of them is copied to the DTD file.

Notation declaration

The 'Notation' meta-property linked to the schema is a list containing several complete notation declarations. Each one of them is copied to the DTD file.

Element type and attribute-list declarations

Such declarations are generated for each non-technical entity type of the schema. The generation is carried out in two steps: element type declarations and attribute-list declarations.

Element type declarations

Let us call <ent>, the non-technical entity type for which the declaration is generated.

An element type declaration has the following general form:

'<!ELEMENT ' <element_type_name> ' ( ' <element_type_content> ' )>'

where :

<element_type_name> is the name of <ent>;

<element_type_content> is built in several steps:

A. Determining the children of <ent> and their cardinality

1. If <ent> contains a 'choice' or 'seq' group, <ent> has more than one child.

Each component of the group becomes an item of the children list of <ent>; the components order in the group is kept:

- | the corresponding child of a '#pcdata' attribute is also a '#pcdata' attribute; its cardinality is [1-1];
- | the corresponding child of a role is the entity type that plays this role; its cardinality is that of the role played by <ent> in the relationship type linking <ent> to this entity type ([0-1], [1-1], [0-N] or [1-N]).
2. If <ent> does not contain a 'choice' or 'seq' group, <ent> has at most one child. If <ent> has a '#pcdata' or '#any' attribute, this attribute is its only child. If <ent> plays a father role in a relationship type, then its child is the entity type that plays the child role in the same relationship type. In other cases, <ent> has no child at all.
B. Building <element_type_content>
A specific declaration (see below) is built for each item of the children list in order to produce <element_type_content>. If there is more than one child, these declarations are separated by a comma (',') or a pipe ('|') depending on the user-defined constraint associated to the group (respectively 'seq' and 'choice').
If <ent> has no child, <element_type_content> is just the 'EMPTY' string (in this case, <element_type_content> is not surrounded by parenthesis).
The declaration corresponding to a child is built according to the following rules:
1. If the child is a '#pcdata' or '#any' attribute, the corresponding declaration is just the '#PCDATA' or 'ANY' string (in this last case ('#any'), <element_type_content> is not surrounded by parenthesis).
2. If the child is a non technical entity type, the declaration is the name of this child followed by a cardinality operator representing its cardinality in the source schema. ('*' for [0-N], '+' for [1-N], '?' for [0-1] and no operator for [1-1]).
3. If the child is a technical entity type, the corresponding declaration has the following pattern: '('<element_type_content> ')' [<repeat_operator>]
where:

-

<element_type_content> lists the children of the technical entity type, following the rules detailed above;

-

<repeat_operator> is the '*', '+' or '?' depending on the cardinality of the technical entity type (i.e. the cardinality of the father role played by its father [0-N], [1-N] or [0-1]).

Attribute-list declarations

An attribute-list declaration is built for each non-technical entity type that has at least one attribute (without considering « #pcdata » or « #any » attributes that have already been handled during entity type declarations).

Let us call <ent>, the non-technical entity type for which the declaration is generated.

Attribute-list declarations have the following pattern:

'<!ATTLIST ' <element_type_name> ' ' <attribute_declaration>+'>'

where:

<element_type_name> is the name of <ent>;

<attribute_declaration>: there are as many <attribute_declaration> as there are attributes in <ent> (except for '#pcdata' and '#any' attributes).

Attribute declaration

Let us call <att>, the attribute of <ent> for which an attribute declaration is generated.

An <attribute_declaration> has the following pattern:

<attribute_name> <attribute_type> <attribute_default>

where:

<attribute_name> is the name of <att>;

<attribute_type> is a specific keyword depending on the situation:

If <att> is the only component of a group submitted to a user-defined constraint, <attribute_type> depends on this constraint:

- | if it is 'gid', <attribute_type> is 'ID';
- | if it is 'idref', <attribute_type> is 'IDREF' (if the maximum cardinality of <att> is 1) or 'IDREFS' (if the maximum cardinality of <att> is N).
Otherwise, <attribute_type> depends on the user-defined type of <att>:
- | if it is 'cdata', <attribute_type> is 'CDATA';
- | if it is 'entity' and if the maximum cardinality of <att> is 1 (resp. N), <attribute_type> is 'ENTITY' (resp.'ENTITIES');
- | if it is 'nmtoken' and if the maximum cardinality of <att> is 1 (resp. N), <attribute_type> is 'NMTOKEN' (resp.'NMTOKENS');
- | if it is 'notation' and if the maximum cardinality of <att> is 1, <attribute_type> is the keyword 'NOTATION' followed by the list of values (between brackets, separated by pipes ('|')) of the 'Notation' meta-property;
- | if it is 'enum', <attribute_type> is the list of values (between brackets, separated by pipes ('|')) of the 'Enum' meta-property.
<attribute_default> is built according to the following rules:
- if the 'Default value' meta-property has a value, <attribute_default> is this value surrounded by quotes
- if the 'Fixed value' meta-property has a value, <attribute_default> is the '#FIXED' string followed by this value surrounded by quotes
- if both the 'Default value' and the 'Fixed value' meta-properties have no value, the following rules are applied:
- | if the minimum cardinality of <att> is 0, <attribute_default> is the '#IMPLIED' string;
- | if the minimum cardinality of <att> is 1, <attribute_default> is the '#REQUIRED' string.


Extraction

Extraction (File/Extract/…)

The extraction tool (File/Extract/…) allows to build physical/logical schemas describing the data structures extracted from:

- | SQL source text files (structure definition script);
- | databases accessed through an ODBC driver;
- | COBOL source text files (file and record structures);
- | IDS/II DDL text files (schema & sub-schemas);
- | IMS source text files;
- | XML DTD files.
If one or more text files are selected in the current process, their structures are extracted into one or several data schemas (depending on the configuration, see File/Configuration…DDL extractors).
If no text file is selected, a dialog box requests a file name. The text file is then added to the project as a product and is connected to the data schema into which its data structures are extracted.
If the current window is a schema window, the extracted specifications are added to its content (Incremental mode); if the current window is the project window, the specifications are extracted into a new schema (New mode).
Note: The Education version provides only the SQL source text extraction tool.

See also:

Data Structure Extraction of SQL files, Data Structure Extraction through ODBC drivers, Data Structure Extraction of COBOL files, Data Structure Extraction of IDS2 files, Data Structure Extraction of IMS files, Data Structure Extraction of XML DTD files.


Data Structure Extraction of XML DTD file

Data Structure Extraction of XML DTD Files

This section describes the rules used by the XML extractor to extract data structures from DTD (Document Type Declaration) files.

There are some limitations on the source DTD files that can be handled correctly by the XML extractor :

- | they cannot contain processing instructions ;
- | they cannot contain IGNORE or INCLUDE sections ;
- | they cannot contain element types of more than 100 characters names because names in DB-MAIN are limited to 100 characters;
- | they cannot contain two element types that bear the same name (regardless of case), since DB-MAIN is case-insensitive and does not accept two entity types that bear the same name.
Notes :
- | the following rules describe DTD files after the replacement of parameter-entity references by their content. Howewer, the XML extractor is able to work on DTD files including parameter entity references;
- | the XML extractor can only handle independent DTD files; it is not intended to process XML files containing DTD declarations.
Workspace:
- | the extractor works on the current project (if any) or creates a new one called 'XML' (otherwise);
- | it works on the current schema (if any) or creates a new one that takes the name of the source file;
- | before starting, the extractor checks the existence of useful user-domains, meta-properties and stereotypes, and creates the missing ones if necessary. They are defined at the end of this page.
Syntax of DTD source files (the actions performed by the extractor are printed in italic):
<DocTypeDecl> :
 | <FirstLine> ( <ElementDecl> | <ListAttDecl> | <EntityDecl> | <NotationDecl> )*
<FirstLine> :
 | '<?xml' [<S> 'version' [<S>] '=' [<S>] '"1.0"'] [<S> 'encoding' [<S>] '=' <S> <Encoding>] [<S>] '?>'
<Encoding> :
 | An encoding format. For ex : "UTF-8".
<ElementDecl> :
 | '<!ELEMENT' <S> <Name> <S> <ContentSpec> [<S>] '>'
 | A new entity type named <Name> is created. In the following descriptions, <ent> will stand for this new entity type.
<ContentSpec> :
 | 'EMPTY'
 | No action.
 | | 'ANY'
 | An atomic attribute named '#any' is added to <ent>.
 | | <Mixed>
 | | <Children>
<Mixed> :
 | '(' [<S>] '#PCDATA' [<S>] ')'
 | An atomic attribute named '#pcdata' is added to <ent>.
 | | '(' [<S>] '#PCDATA' ([<S>] '|' [<S>] <Name>)+ [<S>] ')*'
A new entity type associated with the 'tech' stereotype is created (from now on, such an entity type will be called “technical entity type”). An atomic attribute named '#pcdata' is added to this technical entity type. A rel-type between this entity type and <ent> is created. The cardinality of the role played by <ent> is [0-N] (to represent '*'). The cardinality of the other role is [1-1].
For each <Name>, an entity type named <Name> is created and linked to the technical entity type by a new rel-type. The cardinality of the role played by the technical entity type is [1-1] (since <Name> is not submitted to any cardinality operator). The cardinality of the other role is [1-1] too.
Finally, a group submitted to the 'choice' user-constraint and made up of all the roles played by the <Name> entity types is added to the technical entity type.
<Children> :
 | (<Choice> | <Seq>) [('?' | '*' | '+')]
A technical entity type is created. A rel-type between this entity type and <ent> is created. The cardinality of the role played by <ent> depends on the cardinality operator ('+' [1-N], '*' [0-N], '?' [0-1], no operator [1-1]).
The cardinality of the role played by the technical entity type is [1-1].
<Choice> :
 | '(' [<S>] <ContentParticle> ( [<S>] '|' [<S>] <ContentParticle> )+ [<S>] ')'
For each <ContentParticle> item:
- an entity type is created (see <ContentParticle>);
- a rel-type is created between this entity type and the entity type corresponding to <Choice> (see <Children>);
- the cardinality of the role played by the new entity type is [1-1];
- the cardinality of the other role depends on the cardinality operator associated with <ContentParticle> (see <Children>).
Finally, a group submitted to the 'choice' user-constraint and made up of all the roles played by the <ContentParticle> entity types in the new rel-types is added to the <Choice> entity type
<Seq> :
 | '(' [<S>] <ContentParticle> ( [<S>] ',' [<S>] <ContentParticle> )+ [<S>] ')'
For each <ContentParticle> item:
- an entity type is created (see <ContentParticle>);
- a rel-type is created between this entity type and the entity type corresponding to <Seq> (see <Children>);
- the cardinality of the role played by the new entity type is [1-1];
- the cardinality of the other role depends on the cardinality operator associated with <ContentParticle> (see <Children>).
Finally, a group submitted to the 'seq' user-constraint and made up of all the roles played by the <ContentParticle> entity types in the new rel-types is added to the <Seq> entity type. The roles contained in the new group are ordered according to the order of <ContentParticle> items in <Seq>.
<ContentParticle> :
 | (<Name> | <Choice> | <Seq>) [('?' | '*' | '+')]
 | A new entity type is created. It is named <Name> in the first case. Otherwise, it is given a technical name and is associated to the 'tech' stereotype.
<ListAttDecl> :
 | '<!ATTLIST' <S> <Name> <AttDef>* [<S>] '>'
 | If there is no entity type named <Name>, it is created. In the following descriptions, <ent> will stand for this new entity type.
<AttDef> :
 | <S> <Name> <S> <AttType> <S> <DefaultDecl>
 | An atomic attribute named <Name> is added to <ent>. In the following descriptions, <att> will stand for this new attribute.
<AttType> :
 | <StringType>
 | | <TokenizedType>
 | | <EnumeratedType>
<StringType> :
 | 'CDATA'
 | <att> is given the 'cdata' user-domain.
<TokenizedType> :
 | 'ID'
 | A group composed of <att> is added to <ent>. This group is submitted to the 'gid' user constraint. The maximum cardinality of <att> is 1.
 | |'IDREF'
 | A group composed of <att> is added to <ent>. This group is submitted to the 'idref' user constraint. The maximum cardinality of <att> is 1.
 | |'IDREFS'
 | A group composed of <att> is added to <ent>. This group is submitted to the 'idref' user constraint. The maximum cardinality of <att> is N.
 | |'ENTITY'
 | The maximum cardinality of <att> is 1. <att> is given the 'entity' user-domain.
 | |'ENTITIES'
 | The maximum cardinality of <att> is N. <att> is given the 'entity' user-domain.
 | |'NMTOKEN'
 | The maximum cardinality of <att> is 1. <att> is given the 'nmtoken' user-domain.
 | |'NMTOKENS'
 | The maximum cardinality of <att> is N. <att> is given the 'nmtoken' user-domain.
<EnumeratedType> :
 | <NotationType>
 | | <Enumeration>
<NotationType> :
 | 'NOTATION' <S> '(' [<S>] <Name> ([<S>] '|' [<S>] <Name>)* [<S>] ')'
 | The maximum cardinality of <att> is 1. <att> is given the 'notation' user-domain. The value of the 'Notation' meta-property associated with <att> is a list made up of all <Name>items.
<Enumeration> :
 | '(' [<S>] <Nmtoken> ([<S>] '|' [<S>] <Nmtoken>)* [<S>] ')'
 | The maximum cardinality of <att> is 1. <att> is given the 'enum' user-domain. The value of the 'Enum' meta-property associated with <att> is a list made up of all <Nmtoken> items.
<DefaultDecl> :
 | '#REQUIRED'
 | The minimum cardinality of <att> is 1.
 | | '#IMPLIED'
 | The minimum cardinality of <att> is 0.
 | | ['#FIXED' <S>] <AttValue>
 | The minimum cardinality of <att> is 1.
 | If the string '#FIXED' is present, the value of the 'Fixed value' meta-property associated with <att> is <AttValue>. Otherwise, this value is assigned to the 'Default value' meta-property.
<EntityDecl> :
 | <GeneralEntDecl>
 | | <ParameterEntDecl>
 | Parameter-entity references are ignored by the extractor.
<GeneralEntDecl> :
 | '<!ENTITY' <S> <Name> <S> <EntityDef> [<S>] '>'
 | The entire <GeneralEntDecl> is added to the "Entity" meta-property of the schema.
<NotationDecl> :
 | '<!NOTATION' <S> <Name> <S> (<NotExternalID> | <NotPublicID>) [<S>] '>'
 | The entire <NotationDecl> is added to the "Notation" meta-property of the schema.
Other declarations :
- | <S> stands for a string of space characters;
- | <Name> stands for the name of an XML object. Such names must comply with strict rules;
- | <Nmtoken> stands for 'name token';
- | <AttValue> stands for the content of an attribute.
Description of specific meta-properties and user-domains :
- | 'Notation' and 'Entity': meta-properties associated with schemas (multi-valued - varchar type);
- | 'Notation' and 'Enum': meta-properties associated with atomic attributes (multi-valued - varchar type) ;
- | 'Fixed value': meta-property associated with atomic attributes (single-valued - varchar type ) ;
- | 'Default value' and 'Value constraint': generic meta-properties (not specifically defined for DTD handling);
- | 'cdata', 'notation', 'nmtoken', 'enum' and 'entity': simple user-domains (varchar type).
Notation :
The preceding grammar description uses a simple notation taken from the extended Backus-Naur Form (EBNF). Each rule defines a symbol as follows:
<symbol> : expression
The following conventions are used to describe expressions:
- | 'string' stands for a literal string corresponding to the string between quotes;
- | <symbol> stands for a symbol defined elsewhere in the document.
Given two expressions A and B:
- | [A] stands for A or nothing (A is optional);
- | A B stands for A followed by B (concatenation); concatenation takes precedence over alternation;
- | A | B stands for A or B but not both (alternation);
- | A* stands for multiple consecutive occurrences of A; this operator takes precedence over alternation and concatenation;
- | A+ stands for at least one apparition of A; this operator takes precedence over alternation and concatenation.


Data Structure Extraction of COBOL file

Data Structure Extraction of COBOL Files

This section describes the rules used by the COBOL extractor to extract data structures from COBOL files.

The syntax rules that the COBOL extractor can handle are described below (the actions performed by the extractor are printed in italic):

<program>:
 | <identification_div>
 | [<environment_div>]
 | [<data_div>]
<identification_div>:

IDENTIFICATION DIVISION .

 | PROGRAM-ID . <program_name> .
A schema named “program_name” is created if such a schema does not exist yet.
<environment_div>:
 | ENVIRONMENT DIVISION .
 | [CONFIGURATION SECTION ...]
 | [<in_out_sec>]
<in_out_sec>:
 | INPUT-OUTPUT SECTION .
 | [<file_control_par>]
 | [I-O-CONTROL...]
<file_control_par>:
 | FILE-CONTROL .
 | <select>+
<select>:
 | SELECT [OPTIONAL] <fd_name> ASSIGN [TO] <list_name>
 | [RESERVE INT [AREAS]] [ORGANIZATION [IS] <org_type>]
 | [BLOCK [CONTAINS] INT [TO INT] <rec_char>]
 | [CODE-SET [IS] NAME]
 | [PADDING [CHARACTERS] [IS] NAME]
 | [RECORD DELIMITER [IS] STANDARD]
 | [ACCESS [MODE [IS]] <access_mode>]
 | [RECORD[S] [KEY [IS]] <key_name>] [<alternate_key>+]
 | [[FILE] STATUS [IS] NAME]'.'
A collection named “fd_name” is created. if there is a record clause then "key_name" becomes a primary id and is associated with an access key.
<list_name>:
 | <file_name>
 | | <list_name> <file_name>
 | | <string>
 | | <list_name> <string>
<org_type>:
 | SEQUENTIAL
 | | INDEXED
 | | RELAT
<rec_char>:
 | RECORD
 | | CHARACTERS
<access_mode>:
 | SEQUENTIAL [<rel_key>]
 | | RANDOM [<rel_key>]
 | | DYNAMIC [<rel_key>]
<rel_key>:
 | [RELATIVE [KEY [ARE]] NAME]
 | | [RELATIVE [KEY [IS]] NAME]
<alternate_key>:
 | ALTERNATE RECORD KEY IS NAME [[WITH] DUPLICATES]
The attribute “NAME” is associated with an access key. If "DUPLICATES" is not mentioned, this attribute becomes a secondary id.
<data_div>:
 | DATA DIVISION .
 | [<file_sec>]
<file_sec>:
 | FILE SECTION '.'
 | [<file_desc>+]
<file_desc>:
 | FD NAME [<b_r_l>+] REPORT
 | | FD NAME [<b_r_l>+] .
 | | SD
 | | WORKING-STORAGE
<b_r_l>:
 | BLOCK CONTAINS INT [TO INT] <rec_char>
 | | <record>
 | | LABEL RECORD[S] [IS|ARE] <stand_omi>
 | | VALUE OF NAME IS STRING
 | | AREA[S] IS INT
 | | AREA[S] ARE INT
 | | AREASIZE IS INT
 | | AREASIZE ARE INT
 | | DATA RECORD[S] IS NAME
 | | DATA RECORD[S] ARE NAME
 | | ACCESS MODE [IS] <access_mode>
 | | CODE-SET [IS] NAME
 | | VALUE OF ID [IS] STRING
<rec_char>:
 | RECORD
 | | CHARACTERS
<record>:
 | RECORD CONTAINS INT [FROM INT] [TO INT] CHARACTERS
 | | [RECORD IS] VARYING [IN SIZE] [FROM INT] [TO INT]
 | [CHARACTERS] [DEPENDING [ON] NAME]
<stand_omi>:
 | STANDARD
 | | OMITTED
<list_data_desc>:
 | <data_desc>
 | | <list_data_desc> <data_desc>
<data_desc>:
 | <level> NAME [REDEFINES NAME] [<pict_clause>]
 | [[USAGE [IS|ARE]] <usage_type>] [<occurs_clause>]
 | [VALUE [IS|ARE] <list_literal>] '.'
An entity type named "att_name" is created if the value of "level" is 01.
An attribute named "att_name" is created if "level" is between 02 and 66. This attribute is atomic if there is a "pict_clause”; otherwise it is compound. Moreover, it is multivalued if there is an "occurs_clause".
<pict_clause>:
 | PIC[TURE] [IS] ...
<usage_type>:
 | BINARY
 | | COMP
 | | COMP-1
 | | COMP-2
 | | COMP-3
 | | COMPUTATIONAL
 | | COMPUTATIONAL-1
 | | COMPUTATIONAL-2
 | | COMPUTATIONAL-3
 | | DISPLAY
 | | INDEX
 | | PACKED-DECIMAL
<occurs_clause>:
 | OCCURS INT [TIMES] [ASCENDING | DESCENDING [KEY [IS]] NAME] [INDEXED [BY] NAME]
 | | OCCURS INT TO INT [DEPENDING [ON] NAME] [ASCENDING | DESCENDING [KEY [IS]] NAME] [INDEXED BY NAME]
<list_literal>:
 | <literal>
 | | <list_literal> <literal>
<literal>:
 | STRING
 | | INT
 | | ZEROES
 | | SPACES
 | | INT THRU INT
 | | INT THROUGH INT
 | | STRING THRU STRING
 | | STRING THROUGH STRING
The names of collections and entity types must be unique.
If the name of an attribute is not unique, a (number) suffix is added.
The rules used to find the type of the attribute when processing a picture clause are the following:
- | the attribute is compound if there is no picture clause;
- | the attribute is given the character type if the picture clause contains an "A" or an "X";
- | otherwise it is given the numeric type.
The redefine clause is represented by a group submitted to the "exactly-one" constraint.


Data Structure Extraction of SQL file

Data Structure Extraction of SQL files

This section describes the rules used by the SQL extractor to extract data structures from SQL DDL (data description language) files.

The syntax rules are described below (the actions performed by the extractor are printed in italic; reserved words are printed in bold type):

<sql_file>:
 | <sql> ';'
 | | <sql_file> <sql> ';'
<sql>:
 | <schema>
 | | <base_table_def>
 | | <create_index>
 | | <trigger>
 | | <view_def>
 | | <privilege_def>
 | | <alter_table>
 | | <cursor_def>
 | | <map_section>
 | | <create_dbspace>
 | | <comment_on>
<schema>:
 | CREATE SCHEMA <schema_elt> [<storage_area>*]
 | | CREATE DATABASE FILENAME <schema_elt> [<storage_area>*]
 | | CREATE DATABASE <schema_elt> [<storage_area>*]
A schema named <schema_elt> is created if such a schema does not exist yet.
<schema_elt>:
 | <sch_name> [AUTHORIZATION <name>]
<base_table_def>:
 | CREATE TABLE <table_name> '(' <base_table_element_commalist> ')'
 | [<in_area>*]
An entity type named <table_name> is created. If such an entity type already exists, an error message is displayed and the extractor is stopped.
<base_table_element_commalist>:
 | <base_table_element>
 | | <base_table_element_commalist> ',' <base_table_element>
<base_table_element>:
 | <column_def>
 | | [<const_name>] <table_constraint_def> [<using_index>]
 | [[NOT] DEFERRABLE] [<const_name>]
<using_index>:
 | USING INDEX [<stor_use>*]
<column_def>:
 | <column_name> <data_type> [<default_val>] [<col_const>*]
 | [[NOT] DEFERRABLE]
An attribute named <column_name> is created in the current entity type. It is given the type defined in <data_type>. If an attribute that bears the same name already exists, an error message is displayed and the extractor is stopped.
<data_type>:
 | CHAR[ACTER] ['(' <integer> ')']
character: length= <integer> (default is 1).
 | | VARCHAR ['(' <integer> ')]
var char: length= <integer> (default is 1).
 | | LONG VARCHAR
var char: length= N.
 | | NUMBER ['(' <integer> [',' <integer> ')']]
numeric: length= <integer>, decim = <integer> (defaults are (0,0)).
 | | NUMERIC ['(' <integer> [',' <integer> ')']]
numeric: length= <integer>, decim= <integer> (defaults are (0,0)).
 | | DECIMAL ['(' <integer> [',' <integer> ')']]
numeric: length= <integer>, decim= <integer> (defaults are (0,0)).
 | | SMALLINT ['(' <integer> ')']
numeric: length= 5, decim= <integer> (default is 0).
 | | INT[EGER] ['(' <integer> ')']
numeric: length= 10, decim= <integer> (default is 0).
 | | TINYINT ['(' <integer> ')']
numeric: length= 3, decim= <integer> (default is 0).
 | | LONG
numeric: length= 18.
 | | BIGINT ['(' <integer> ')']
numeric: length= 18, decim= <integer> (default is 0).
 | | QUADWORD ['(' <integer> ')']
numeric: length= 18, decim= <integer> (default is 0).
 | | LIST_BYTE ['(' <integer> ')']
var char: length= <integer> (default is 1).
 | | FLOAT '(' <integer> ')'
float: length= <integer> (default is 8).
 | | REAL
float: length= 8.
 | | DOUBLE PRECISION
float: length= 15.
 | | DATE
date.
 | | DATE ANSI
date.
 | | DATE VMS
date.
 | | TIME <integer>
date.
 | | TIMESTAMP <integer>
date.
 | | INTERVAL <integer>
date.
<default_val>:
 | DEFAULT <literal>
 | | DEFAULT USER
 | | DEFAULT NULL
 | | DEFAULT CURRENT_DATE
 | | DEFAULT CURRENT_TIME
 | | DEFAULT CURRENT_TIMESTAMP
<col_const>:
A group or a constraint associated with the current attribute is created.
 | PRIMARY KEY [<const_name>]
The attribute is a primary id.
 | | UNIQUE [<const_name>]
The attribute is a secondary id.
 | | NOT NULL [<const_name> ]
The minimum cardinality of the attribute is 1.
 | | NULL [<const_name> ]
The minimum cardinality of the attribute is 0.
 | | CHECK <check_condition> [<const_name>]
A new processing unit is attached to the current table; the check clause is added to its technical description.
 | | REFERENCES <table_name> ['(' <column_commalist> ')'] [<const_name>]
A referential constraint is defined between the attribute and the primary id of the table <table_name> (it must contain the attributes <column_commalist>).
<table_constraint_def>:
 | PRIMARY KEY '(' <column_commalist> ')'
<column_commalist> becomes a primary id.
 | | UNIQUE '(' <column_commalist> ')'
<column_commalist> becomes a secondary id.
 | | CHECK <check_condition>
A new processing unit is attached to the current table; the check clause is added to its technical description.
 | | FOREIGN KEY '(' <column_commalist> ')'
 | REFERENCES <table_name> [ '(' <column_commalist> ')']
A referential constraint is defined between the attribute(s) of the first <column_commalist> and the primary id of the table <table_name> (if the second '<column_commalist>' is empty) or between the attribute(s) of the first <column_commalist> and the attribute(s) of the second <column_commalist> (the latter must represent a primary or a secondary identifier).
<column_commalist>:
 | <column_name>
 | | <column_commalist> ',' <column_name>
<column_index>:
 | <column_name> <asc_desc>
 | | <column_commalist> ',' <column_name> <asc_desc>
<asc_desc>:
 | ASC
 | | DESC
<create_index>:
 | CREATE [UNIQUE] INDEX <index_name>
 | ON <table_name> '(' <column_indext> ')
An access key group named <index_name> is added to the entity type <table_name> (which muste contain the attributes <column_commalist>). If "UNIQUE" is mentioned, the group becomes a secondary id.
<view_def>:
 | CREATE [OR REPLACE] VIEW <view_name> [(<column_commalist>)]
 | <as_query_spec>
An entity type <view_name> containing the attributes <column_commalist> is created in a second schema. If the second schema does not exist yet, it is created. The view creation source text is added to the technical description of the new entity type.
<trigger>:
 | CREATE <trigger-def>
A new processing unit is attached to the current table; the trigger definition is added to its technical description.
<privilege_def>:
 | <grant>
A grant clause is added to the technical description of the schema.
<alter_table>:
 | ALTER TABLE <name> <alter_elt_list>
<alter_elt_list>:
 | <alter_elt>
 | | <alter_elt_list> <alter_elt>
<alter_elt>:
 | ADD COLUMN <column_def>
A new attribute is added to the current entity type (see <column_def>).
 | | ADD {( | CONSTRAINT} [<const_name>] <table_constraint_def>
A new constraint is added to the current entity type (see <table_constraint_def>).
 | [<const_name>] [[NOT] DEFERRABLE] [)]
 | | DROP COLUMN <column_name>
 | | DROP CONSTRAINT <name>
 | | ALTER <column_name> <data_type>
<cursor_def>:
 | DECLARE <name> <cursor_def>
The cursor definition is added to the technical description of the schema.
<storage_area>:
 | STORAGE AREA <area_name>
A collection named <area_name> is created.
<map_section>:
 | CREATE STORAGE MAP <name> FOR <table_name>
The entity_type named <table_name> is added to the collection named <storage>.
<storage>:
 | STORE RANDOMLY ACROSS (<area_list>)
 | | STORE IN <area_name>
<area_list>:
 | <area_name>
 | | <area_list>, <area_name>
<create_dbspace>:
 | CREATE DBSPACE <area_name>
A new collection named <area_name> is created.
 | | CREATE TABLESPACE <area_name> <name>
A new collection named <area_name> is created.
<in_area>:
 | IN <area_name>
The current entity type is added to the collection named <area_name>.
 | | <stor_use>
<stor_use>:
 | STORAGE ...
 | | PCTFREE <integer>
 | | PCTUSED <integer>
 | | TABLESPACE & <name>
 | | TABLESPACE <name>
<comment_on>:
 | COMMENT ON TABLE <table_name> IS ' ... '
 | | COMMENT ON COLUMN <column_name> IS ' ... '
<literal>:
 | <string>
 | | <integer>
<table_name>:
 | <name>
 | | <name> '.' <name>
<const_name>:
 | [CONSTRAINT] <name>
<sch_name>:
 | <name>
<column_name>:
 | <name>
<view_name>:
 | <name>
<index_name>:
 | <name>
<area_name>:
 | <name>
<check_condition>:
 | '(' ... ')'
<as_query_sec>:
 | AS ...
<cursor_def>:
 | CURSOR ...
<trigger>:
 | TRIGGER ...
<grant>:
 | GRANT ...
<name>:
 | [A-Za-Z][A-Za-z0-9]*
<int>:
 | [0-9][0-9]*
<string>:
 | "..."

The DB_MAIN.INI file contains a section "[Xtrt_SQL]" that defines the default behavior of the SQL extractor. Those options can be modified (File/ Configuration). The configurable parameters are the following:

(SQL) Views and tables are in the same schema:

if checked, view creations and table declarations are translated as entity types in the same schema; otherwise they are translated as entity types in separate schemas.

(SQL) Columns are “NULL” by default:

if checked, columns are "NULL" by default; otherwise they are “NOT NULL” by default.


Data Structure Extraction throught ODBC driver

Data Structure Extraction through ODBC drivers

This section describes how to extract the physical schema of a database using the ODBC extractor. An ODBC driver (version 3 or higher) is required to use this extractor.

Before executing the ODBC extractor, an ODBC data source must be configured. To do this, refer to your database manual, ODBC driver manual or to your database administrator. When you call the ODBC extractor (File/Extract/ODBC) the standard ODBC administration dialog box appears to select which data source you want to use. When the data source has been selected, a new dialog box requires the name of the schema that must be extracted. The notion of schema varies from one RDBMS to the other. In some RDBMS (Access), there is no schema, so just click on the Ok button. For other ones (such as Oracle), each user has got his/her own schema. If no schema name is given, the extractor will extract all the schemas defined in the database. If only one schema is needed, its name must be given.

This extractor recovers the tables, columns, primary keys, index (unique or not) and foreign keys.


Data Structure Extraction of IDS/II file

Data Structure Extraction of IDS/II files

See Data Structure Extraction of IMS files.


Data Structure Extraction of IMS file

Data Structure Extraction of IMS files

This section describes the rules used by the IMS extractor to extract data structures from IMS DDL (data description language) files. The following specifications are taken from the Master Thesis of Ph. Richard (La Rétro-Ingénierie des Bases de Données, Application à IMS - 1995).

Reserved words are printed in bold type.

<ims_file> :
 | <ims_database>
 | | <ims_file> <ims_database>
<ims_database> :
 | <HSAM_database>
 | | <HISAM_database>
 | | <HDAM_database>
 | | <HIDAM_database>
 | | <MSDB_database>
 | | <DEDB_database>
 | | <INDEX_database>
 | | <logical_database>

HSAM database

<HSAM_database> :
 | DBD
 | NAME=<dbname1> ,ACCESS={HSAM SHSAM}
 | DATASET
 | DD1=<ddname1> ,DD2=<ddname2>
 | [,BLOCK=(<blk_fact1>,<blkfact2>)][,RECORD=(<reclen1>,<reclen2>)]
 | SEGM
 | NAME=<segname1> ,PARENT={0 <segname2>}
 | ,BYTES=<maxbytes>[,FREQ=<freq>]
 | FIELD
 | NAME=(<fldname1>[,SEQ,{M U}])
 | ,BYTES=<bytes>
 | ,START=<startpos>
 | [,TYPE={X P C}]
 | DBDGEN
 | [FINISH]
 | END

HISAM database

<HISAM_database> =
 | DBD
 | NAME=(<dbname1>),
 | ACCESS={(HISAM [,VSAM])(SHISAM [,VSAM])}[,PASSWD={YES NO}]
 | [<exit>]
 | [,VERSI0N='<n>']
 | DATASET
 | DD1=<ddname1> ,OVFLW=<ddname3> [,BLOCK=(<blk_fact1>,<blkfact2>)]
 | [,SIZE=(<size1>,<size2>)][,RECORD=(<reclen1>,<reclen2>)]
 | SEGM
 | NAME=<segname1>,
 | PARENT={0 (<segname2>[<lpsegname>
 | [,{VIRTUAL PHYSICAL}][,<dbname1>])}
 | ,BYTES=<maxbytes>[,<minbytes>][,FREQ=<freq>]
 | [,POINTER={LPARNT CTR PAIRED}]
 | [,RULES=([{L P V}{L P V B}{L P V},]{LAST FIRST HERE})]
 | [,SOURCE=(<segname>,{DATA KEY},<dbname>)]
 | [<exit>]
 | [,COMPRTN={(<routname>,{DATA KEY},INIT)
 | (<routname>[{[,DATA],INIT,INIT}])}]
 | LCHILD
 | NAME=(<segname1>,<dbname>)[,POINTER=[{DBLE NONE SYMB}]]
 | [,PAIR=<segname2>][,RULES={LAST FIRST HERE}]
 | FIELD
 | NAME={(<fldname1>[,SEQ,{M U}])<syst_rel_fldname>}
 | ,BYTES=<bytes>,START=<startpos>[,TYPE={X P C}]
 | XDFLD
 | NAME=<fldname>[,SEGMENT=<segname>][,CONST=<char>]
 | ,SRCH=<list1>[,SUBSEQ=<list2>][,DDATA=<list3>]
 | [,NULLVAL=<value1>][EXTRTN=<name1>]
 | DBDGEN
 | [FINISH]
 | END

HDAM database

<HDAM_database> :
 | DBD
 | NAME=(<dbname1>),ACCESS=(HDAM [,{OSAM VSAM}])
 | RMNAME=(<random>[,<numrap>,<sizeblock>,<sizeraa>])
 | [,PASSWD={YES NO}]
 | [<exit>]
 | [,VERSI0N='<n>']
 | DATASET
 | DD1=<ddname1>[,BLOCK=<blk_fact1>][,SIZE=(<size1>)]
 | [,SCAN=<cyl_num>][,FRSPC=(<free_block_freq>,<%free_space>)]
 | [,SEARCHA={0 1 2}]
 | SEGM
 | NAME=<segname1>
 | <parent>
 | ,BYTES=<maxbytes>[,<minbytes>][,FREQ=<freq>]
 | [,POINTER={HIER HIERBWD TWIN TWINBWD NOTWIN}
 | ,{LTWIN LTWINBWD} ,{LPARNT CTR PAIRED}]
 | [,RULES=([{L P V}{L P V B}{L P V},]
 | {LAST FIRST HERE})] [,SOURCE=(<segname>,{DATA KEY},<dbname>)]
 | [<exit>]
 | [,COMPRTN={(<routname>,{DATA KEY},INIT)(<routname>[{[,DATA],INIT
 | ,,INIT}])}]
 | LCHILD
 | NAME=(<segname1>,<dbname>)
 | [,POINTER=[{DBLE NONE INDX SYMB}]][,PAIR=<segname2>]
 | [,RULES={LAST FIRST HERE}]
 | FIELD
 | NAME={(<fldname1>[,SEQ,{M U}]) <syst>_<rel>_<fldname>}
 | ,BYTES=<bytes>,START=<startpos>[,TYPE={X P C}]
 | XDFLD
 | NAME=<fldname>[,SEGMENT=<segname>][,CONST=<char>]
 | ,SRCH=<list1>[,SUBSEQ=<list2>][,DDATA=<list3>]
 | [,NULLVAL=<value1>][EXTRTN=<name1>]
 | DBDGEN
 | [FINISH]
 | END

HIDAM database

<HIDAM_database> :
 | DBD
 | NAME=<dbname1>
 | ,ACCESS=(HIDAM [,{OSAM VSAM}])
 | [,PASSWD={YES NO}]
 | [,<exit>][,VERSI0N='<n>']
 | DATASET
 | DD1=<ddname1>[,BLOCK=<blk_fact1>][,SIZE=(,<size1>)]
 | [,SCAN=<cyl_num>][,FRSPC=(<free_block_freq>,<%free_space>)]
 | [,SEARCHA={0 1 2}]
 | SEGM
 | NAME=<segname1>,<parent>
 | ,BYTES=<maxbytes>[,<minbytes>][,FREQ=<freq>]
 | [,POINTER={HIER HIERBWD TWIN TWINBWD NOTWIN}
 | ,{LTWIN LTWINBWD},{LPARNT CTR PAIRED}]
 | [,RULES=([{L P V}{L P V B}{L P V}],{LAST FIRST HERE})]
 | [,SOURCE=(<segname>,{DATA KEY},<dbname>)]
 | [,<exit>][,COMPRTN={(<routname>,{DATA KEY},INIT)
 | (<routname>[{[,DATA],INIT,,INIT}])}]
 | LCHILD
 | NAME=(<segname1>,<dbname>)
 | [,POINTER=[{DBLE NONE INDX SYMB}]][,PAIR=<segname2>]
 | [,RULES={LAST FIRST HERE}]
 | FIELD
 | NAME={(<fldname1>[,SEQ,{M U}]) <syst_rel_fldname>}
 | ,BYTES=<bytes>,START=<startpos>[,TYPE={X P C}]
 | XDFLD
 | NAME=<fldname>[,SEGMENT=<segname>][,CONST=<char>]
 | ,SRCH=<list1>[,SUBSEQ=<list2>][,DDATA=<list3>]
 | [,NULLVAL=<value1>][EXTRTN=<name1>]
 | DBDGEN
 | [FINISH]
 | END

MSDB database

<MSDB_database> :
 | DBD
 | NAME=<dbname1>,ACCESS=MSDB
 | DATASET
 | ,REL=({NO TERM[,<fldnm>] FIXED[,<fldnm>] DYNAMIC[,<fldnm>]})
 | SEGM
 | NAME=<segname1>,BYTES=<maxbytes>
 | FIELD
 | NAME=(<fldname1>[,SEQ,U]),BYTES=<bytes>
 | ,START=<startpos>[,TYPE={X P C H F}]
 | DBDGEN
 | [FINISH]
 | END

DEDB database

<DEDB_database> :
 | DBD
 | NAME=(<dbname1>),ACCESS=DEDB
 | RMNAME=<random>[,<exit>][,VERSI0N='<n>']
 | [,PASSWD={YES NO}]
 | AREA
 | DD1=<ddname1>,SIZE=<size1>,UOW=(<num1>,<overfl1>)
 | ,ROOT=(<num2>,<overfl2>)
 | SEGM
 | NAME=<segname1>,<parent>
 | ,BYTES=<maxbytes>,<minbytes>,TYPE={DIR SEQ}
 | [,RULES={HERE LAST FIRST}][,SSPTR=<n>]
 | [,<exit>][,COMPRTN={(<routname>,{DATA KEY},INIT)
 | (<routname>[{[,DATA],INIT,,INIT}])}]
 | FIELD
 | NAME=(<fldname1>[,SEQ,U]),BYTES=<bytes>
 | ,START=<startpos>[,TYPE={X P C}]
 | DBDGEN
 | [FINISH]
 | END

INDEX database

<INDEX_database> :
 | DBD
 | NAME=(<dbname1>,...),ACCESS=(INDEX[,VSAM]
 | [,{PROT NOPROT}][,DOSCOMP])[,PASSWD={YES NO}]
 | DATASET
 | DD1=<ddname1>[,BLOCK=(<blkfact1>,<blkfact2>)]
 | [,SIZE=(<size1>,<size2>)][,RECORD=(<reclen1>,<reclen2>)]
 | SEGM
 | NAME=<segname1>[,PARENT=0],BYTES=<bytes>
 | [,FREQ=<freq>]
 | LCHILD
 | NAME=(<segname1>,<dbname>)[,POINTER={SNGL SYMB}]
 | ,INDEX=<fldname>
 | FIELD
 | NAME=(<fldname1>[,SEQ,U]),BYTES=<bytes>
 | ,START=<startpos>[,TYPE={X P C}]
 | DBDGEN
 | [FINISH]
 | END

Logical database

<logical_database> :
 | DBD
 | NAME=<dbname1>,ACCESS=LOGICAL
 | DATASET
 | LOGICAL
 | SEGM
 | NAME=<segname1>,PARENT={0 <segname2>}
 | ,BYTES=<maxbytes>[,FREQ=<freq>]
 | DBDGEN
 | [FINISH]
 | END
<exit> :
 | EXIT= (<exit_routine>+ )
<exit_routine> :
 | ([<routine_name>] [<cascade>] [<log>])
<routine_name> :
 | *
 | | <exitname> [,{KEY NOKEY}]
 | [,{NOPATH PATH}][,{DATA NODATA}]
<cascade> :
 | ,{CASCADE
 | | ,(CASCADE [,{KEY NOKEY}][,{DATA NODATA}][,{NOPATH PATH}])
 | | ,NOCASCADE
<log> :
 | LOG
 | | NOLOG
<parent> :
 | PARENT= <parent_def>
<parent_def> =
 | 0
 | | (<segname2>[<lpsegname>
 | [,{VIRTUAL PHYSICAL}][,<dbname1>])


The File menu

F ile menu

New project... | to build a new project;
Open project... | to open an existing project;
Save project | to save the current project (*.lun file);
Save project as... | to save the current project as a new *.lun, *.isl or *.xml file. (ISL format does not save UML Use Case and Activity diagrams, method and project history; XML format saves everything but the method);
Close project | to close the current project;
Project properties... | to examine/modify the properties of the current project.
__________
Export ... | to generate an *.isl file representing the selected objects of the current window (data schemas in the project view, objects and their descendants in a data schema view);
Import ... | to import schema(s) from an *.isl file into the current project.
__________
Execute plug-in ... | to run a compiled Voyager 2 program (*.oxo file) or a java class program;
Continue plug-in ... | to resume an interrupted Voyager 2 program;
Rerun plug-in ...(1) | to execute once more the most recently used (if any) Voyager 2 program without loading it again.
User tools
User tools 1 User tools 2 User tools 3 User tools 4 User tools 5 User tools 6 User tools 7 User tools 8 User tools 9 User tools 10 | to call commands from one of the 10 configurable tool menus; each of these can contain shortcuts to maximum 25 Voyager 2 programs or menu commands; to define these menus, see File/Configuration/User-defined menu; their definitions are saved in the DB_MAIN.INI file.
__________
Extract | to build a logical schema describing the data structures extracted from:
SQL... | ... a SQL source text file;
ODBC…(1) | … a database accessed through an ODBC driver;
COBOL... (1) | ... a COBOL source text file (file and record structures);
IDS/II... (1) | ... an IDS/II DDL text file (schema & sub-schemas);
IMS... (1) | ... an IMS source text file;
XML... (1) | ... a XML DTD text file;
Generate | to generate a program that creates the structures corresponding to the current schema, according to one of the following models:
Standard SQL... | standard SQL code;
Access... | Access code;
Interbase... | Interbase code;
MySQL... | MySQL code;
PostgreSQL... | PostgreSQL code;
Academic SQL... (1) | academic SQL code;
__________
Parametric SQL generator... (1) | parameterized SQL code (using a parametric SQL generator written in Voyager 2)
__________
COBOL... (1) | COBOL files(Environment Section and Data Section);
__________
CODASYL... (1) | Codasyl or IDS/II program (schema and sub-schemas);
__________
XML... | XML DTD file.
__________
Edit text file... | to use Notepad in order to visualize an ASCII file.
__________
Report... | to generate a report of the current schema or source file window;
Textual view ... | to generate a dictionary report of a data schema (only textual view) or source file window into a file (*.dic);
RTF... | to generate a standard RTF report (only for schema windows) by means of a Voyager 2 program;
Custom...(1) | to generate a custom report (only for schema windows) by means of a Voyager 2 program.
The last two report generators are Voyager 2 programs. Before first use, the paths to the appropriate *.oxo files must be set in the configuration dialog box (File/Configuration…Report generators).
Print | to print the content of the current process, schema or source file window;
Printer setup... | to choose a printer.
__________
Configuration ... | to set some DB-MAIN options.
__________
Exit | to exit DB-MAIN.
__________
File1 | to open the last opened file (*.lun or *.isl);
File2 | to open the last but one opened file (*.lun or *.isl);
etc | ...
(1) not available in the Education version.

See also:

Project manipulation.


Project manipulation

DB-MAIN has an internal specification language (Load/UNload formatted text, or LUN). This format is used to save the project description on disk (compact and unreadable).

It is contained in a file with a .lun extension.

The File/New project... menu item is used to create a new project.

The File/Project Properties... menu item is used to display and/or modify the properties of the current project.


Import data schema

The (File/Import) menu command allows to import data schemas from an ISL or XML file into the current project.

When opening an ISL or XML file, DB-MAIN displays the list of all data schemas that are defined in the file. The user can thus those that must be imported into the current project.

If a selected data schema does not exist yet in the project, it is added to it.

If a selected data schema already exists in the project with the same name and version, the imported data schema is renamed.

Note: importing XML format is available in DB-MAIN 7.1 and higher.

See also:

Export.


Export

DB-MAIN allows to export DB-MAIN projects to XML format (version 7.1 and higher), which should allow most other CASE tool on the market to integrate DB-MAIN projects.

DB-MAIN also has another textual format, i.e. the external specification language (Information System Specification Language, or ISL) with which any specification can be expressed. This language allows communication between tools, selective backup or even data input (verbose and readable).

It is contained in a file with an .isl extension. The ISL format is used to export projects.

This function generates an ISL file representing the selected objects of the current schema or project:

- if no object is selected, it generates an empty project;

- if a data schema is selected in the project view, it generates a file containing the data schema with its content;

- if an object is selected in a data schema view, it generates a file containing the selected object and its descendants.

Note: the ISL format is bound to disappear in future DB-MAIN versions. Henceforth, XML will be the preferred export format; ISL will then be used only for integration of projects.


Generate a report

If the current window displays a textual view of a data schema, it can be saved into a text file (File/Report/Textual view...). The Print dictionary dialog box has the following features:

Include semantic descriptions | : | if checked, the semantic descriptions of all objects are saved to the file;
Include technical descriptions | : | if checked, the technical descriptions of all objects are saved to the file;
Separator | : | to enter the text that must be printed before each semantic (respectively technical) description; this text can contain any character (to enter a tabulation, use <ctrl+tab>);
Prefix marked lines by | : | to specify the characters (2) that must be printed before marked objects;
Include meta-property values | : | if checked, the values of all meta-properties are saved to the file;
Write to file | : | to give the file name (.dic extension);
Browse | : | to give the file path;
Show report generation | : | if checked, the file generation (primitive process) and the generated text file (product) are represented in the current process window;
Help | : | to get help information on the purpose;
Ok | : | to close the dialog box and generate the report with the chosen options;
Cancel | : | to close the dialog box without executing any action.

If the current window displays a source text, it can be saved into a text file. (File/Report/Textual view...). The Print dictionary dialog box has the following features:
Include descriptions | : | if checked, all textual descriptions are saved to the file;
Separator (before et after) | : | to enter the text that must be printed before (respectively after) each textual description;
Prefix marked lines by | : | to specify the characters (2) that must be printed before marked lines;
Include line number | : | if checked, the line numbers are saved to the file;
Write to file | : | to give the file name (.dic extension);
Browse | : | to give the file path;
Show report generation | : | if checked, the file generation (primitive process) and the generated text file (product) are represented in the current process window;
Help | : | to get help information on the purpose;
Ok | : | to close the dialog box and generate the report with the chosen options;
Cancel | : | to close the dialog box without executing any action.


Configuration dialog

Configuration dialog box

The File/Configuration menu item is used to configure DB-MAIN (by modifying the db_main.ini file)

The Configuration dialog box is divided into three parts:

Section: | displays the list of all configuration sections;
Entry: | displays the list of all entries associated to the selected section;
Editing: | displays and allows to edit the value of the selected entry.
The editing part can be of different kinds (check box, editable text field, editable text field plus Browse or Color button, list box) depending on the type of the entry selected.
To modify an entry, select its section and the entry itself. Use the Editing zone to change its value and click on the Change button to validate.
The Close button is used to close the dialog box.
The configurable entries are listed below:
Code generators: | to associate Voyager 2 programs with code generators. Such programs must contain a procedure that has the following declaration :
 | export procedure generate(string: file_name)
 | where file_name is the name of the file to generate.
 | COBOL generator (v2): the Voyager 2 program called by the File/Generate/COBOL menu command;
 | CODASYL generator (v2): the Voyager 2 program called by the File/Generate/CODASYL menu command;
 | XML DTD generator (v2): the Voyager 2 program called by the File/Generate/XML menu command.
DDL extractors: | to set the default behavior of extractors:
 | All files in the same schema: if checked, all selected files are extracted in the same schema;
 | (SQL) Columns are "NULL" by default: if checked, columns are "NULL" by default; otherwise they are “NOT NULL” by default;
 | (SQL) Views and tables are in the same schema: if checked, view creations and table declarations are translated as entity types in the same schema; otherwise they are translated as entity types in separate schemas.
 | XML DTD extractor (v2): the Voyager 2 program called by the File/Extract/XML menu command.
Default directories: | to set the environment default directories. DB-MAIN uses the current Windows directory if no default value is set (empty string) for a directory:
 | Project default directory (*.lun): the default directory where *.lun files can be saved or loaded (File/Open, File/Save as);
 | Voyager 2 program default directory (*.oxo): the default directory where *.oxo files can be found (File/Execute Voyager);
 | Pattern default directory: the default directory where pattern files (.pdl) can be saved or loaded (Assist/Text analysis/Load pattern);
 | Extraction default directory: the default directory where source files (to be extracted) can be found (File/Extract/...);
 | Generation default directory: the default directory where generated files are saved (File/Generate/...).
Inter-groups constraints: | Verify matching groups for referential or inclusion constraints: If checked, the constraint dialog box checks whether the selected group can be the source of a referential or an inclusion constraint.
Logging: | to set the default behavior of the logging process:
 | Trace off by default: If checked, the trace flag (Log/Trace) is off for all new schemas;
 | Log only replay information: If checked, the log file traces only the pieces of information needed to replay it, and not those needed for design recovery. This flag is read-only when a schema is opened.
Method: | In a method window:
 | Color of unused process types (R,G,B): to choose the color used to mark those process types that have not been used so far;
 | Color of used process types (R,G,B): to choose the color used to mark those process types that have already been used;
 | Color of allowed process types (R,G,B): to choose the color used to mark those process types that are currently allowed;
 | Color of process types under execution (R,G,B): to choose the color used to mark those process types that are under execution;
 | Paint background of unused process types: If checked, the background of so far unused process types is painted the same color as the border;
 | Paint background of used process types: If checked, the background of already used process types is painted the same color as the border;
 | Paint background of allowed process types: If checked, the background of currently allowed process types is painted the same color as the border;
 | Paint background of process types under execution: If checked, the background of process types under execution is painted the same color as the border.
Report generators: | to associate Voyager 2 programs with report generators:
 | RTF generator (v2): the Voyager 2 program called by the File/Report/RTF menu command;
 | Custom generator (v2): the Voyager 2 program called by the File/Report/Custom menu command.
Schema analysis: | Library of rules: the default library of rules used by the Schema analysis assistant (*.anl file, default is default.anl).
Text analysis: | Secondary file of patterns: to select the secondary file containing patterns definitions;
 | Main file of patterns: to select the main file containing patterns definitions;
 | Only the variables of the dependency graph can be colored: to set the default behavior of the dependency graph. If checked, only the variables of the dependency graph are colored when the right mouse button is clicked in a source file. Otherwise, the other variables are colored as well.
 | Color of variables in the Dependency graph: to choose the color used to mark the variables of the dependency graph;
 | The lines copied to the clipboard are prefixed by their number: if checked, the selected lines of the source file are copied into the clipboard together with their line number;
 | Color of the lines belonging to a program slice: to choose the color used to mark the lines that belong to a program slice.
Transformations: | Library of transformations: to choose the default library of transformations for the Global transformation assistant (*.tfl file, default is default.tfl);
 | Technical identifier type (char or num): to set the default type of generated technical identifiers (ADD_TECH_ID transformation);
 | Technical identifier length (integer >= 0): to set the default length of generated technical identifiers (ADD_TECH_ID transformation).
User-defined menu: | To display the list of tools contained in each user toolbar:
 | The Edit button allows to edit this list. The top half of the new dialog box shows the tools contained in the selected toolbar and three buttons to move a line in the list or to remove a line from the list. The lower part allows to add new tools to the toolbar. Each new tool must be given a name (that will be used as a shortcut in the File/User tools menu and in the User tools palette) and be associated with a function (either a Voyager 2 program (via the Browse button) or a menu item).
View settings: | to set the default settings for textual and graphical views:
 | Default font in textual schema views: to choose the default font for future windows displayed in a textual schema view;
 | Default font in graphical views: to choose the default font for future windows displayed in a graphical schema view;
 | Default font in source views: to choose the default font for future source windows;
 | Default font in description dialog boxes: to choose the default font for descriptions (semantic, technical, notes,…);
 | Default zoom in graphical views: to choose the default zoom value for future windows displayed in a graphical schema view;
 | Default reduce in graphical views: to choose the default reduce value for future windows displayed in a graphical schema view;
 | Line thickness for the <copy graphic> function: to set the line thickness used by the Copy graphic function;
 | String before a stereotype: to set the string printed before a stereotype (default is "<<");
 | String after a stereotype: to set the string printed after a stereotype (default is ">>");
 | Note color in graphical views (R,G,B): to choose the background color of notes in graphical views;
 | Maximum width of notes in graphical views (in centimeters): to set the maximum width of notes; when lines exceed the given value, they are wrapped;
 | Minimum entity type width in graphical views (in centimeters): to define the minimum width of entity types; white spaces are added to entity types that would normally be smaller than the given value.


The Edit menu

E dit menu

Save point | to save a copy of the current schema (in a data schema view);
Rollback | to restore the last copy of the current schema (in a data schema view);
Undo | to undo the last action performed on the current schema (in a data schema view).
__________
Copy | Ctrl+C | to copy the selected objects to the clipboard (in a schema view);
 |  | to copy the selected lines to the clipboard (in a source text view);
Paste | Ctrl+V | to paste the content of the clipboard into the current schema;

Copy graphic

to copy the graphical representation of the selected objects to the clipboard.

__________

Select all

Ctrl+A

to select all the objects of the current schema or project (graphical views only);

Mark selected | to mark / unmark all the selected objects (or lines) in the current schema, project or source text;
Select marked | to select all the marked objects (or lines) in the current schema, project or source text;
Color selected | to color all the selected objects (or lines) in the current schema, project or source text (to choose the default color, see Change color);
Remove color | to color black all the selected objects (or lines) in the current schema, project or source text.
__________
Delete | Del | to delete all the selected objects in the current schema or project;
__________
Goto |  | for data schema and activity diagrams, the corresponding object state (in activity diagram) of the selected object (in data schema) is highlighted and conversely;
__________
Change color... | to change the default color with the chosen one and color all selected objects (if any);
Change font... | to change the font and character size in any textual, graphical or source text view.

See also:

Copy/paste.


Save point

The Save point function allows to save a copy of the current schema in order to restore it later on if needed (through the "Rollback” function).


Rollback

The Rollback function allows to restore the last "save point" of the current schema. The current version of the schema is lost. This function only restores the current schema and not the whole project.


Undo

DB-MAIN allows to undo (Edit/Undo) the last action performed on a data schema. DB-MAIN commands are divided into three categories, according to the type of undo available on them:

No Undo: no undo is available for this category of commands (mainly transformations).

Undo the last modification: for this category of commands, undo replays the reverse of the last action recorded in the log. To enable this function, the Log/Trace must be on and the log must record the information needed for design recovery (see configuration of the loggingConfig). This category includes creation, modification, deletion and move of objects.

Restore a copy of the schema: to undo the commands that perform major modifications on a schema (i.e. global transformations, advanced transformations, schema integrations), a copy of the current schema is stored before the modification and can be restored if needed.


Copy - Paste

If the active window is a schema, the Copy command copies the selected objects to the clipboard. They can then be added to any schema of the current project with the help of the Paste command. To paste an attribute, the current object must be an entity type, a rel-type or another attribute. To paste a processing unit, the current object must be an entity type, a rel-type, another processing unit or a schema.

If the active window is a source text browser, the Copy command copies the selected lines to the clipboard with or without the line number (depending on the configuration, see text analysis settings).


Copy graphic

If the active window is a graphical view of a schema or a project, the Copy graphic command copies the graphical representation of the selected objects to the clipboard. This representation can then be pasted into another application program such as a word processor.


Goto object state

If some data schema objects were referenced into activity diagrams, this function allows to highlight the object (in data schema) or one of its states (in activity diagrams):

If the active window is a data schema, the Goto command highlights the state corresponding to the current object in a data schema. If several states reference the selected object, the user must choose the right state in a dialog box.

If the active window is an activity diagram, the Goto command highlights the data object corresponding to the selected state.


Color

Change color

The Change color command allows to change the color of the selected objects.


Font

Change font

If the current window is a textual or graphical view of a schema, a project view or a text file, the Change font command allows to change the font and size of all characters in this window.


The Product menu

P roduct menu

The Product menu contains functions dedicated to the manipulation of products of the current project.

New schema... | to create a new schema;
Add text... | to add a text file;
New set... | to add a new product set;
Open... | to open the current product;
Properties... | to examine/modify the properties of the current product;
Copy product ... | to generate a copy of the current schema in the project window;
View | (not available in the Education version);
Define view ... | to define a new view containing the marked objects of the current schema;
Generate view ... | to generate a view defined on the current schema;
Mark view ... | to mark the objects belonging to a view of the current schema;
Remove view ... | to remove a view defined on the current schema;
Copy view ... | to copy a view defined on the current schema;
Rename view ... | to rename a view defined on the current schema.
__________
Properties ... | to add, remove, examine or modify meta-properties in the DB-MAIN repository;
User-domains ... | to create, remove, examine or modify user-defined domains.
__________
Lock/Unlock | to put a lock on a product (only when the control level is not “no use of a methodology, no history control”, see Engineering/Control) or remove it.


Copy schema

Copy product

In the project window:

The Product/Copy product is used to make a copy of the current product. A dialog box (Schema or Text properties, depending on the selected product) allows to enter the name and version (and short name for a schema) of the new product.

In a (graphical or textual) schema window:

The Product/Copy product command is used to make a copy of the current schema,. A Schema properties dialog box allows to enter the name, short name and version of the new schema.

Note: the source and the copy are the same type (ER schema, UML Class Diagram, UML Activity Diagram, UML Use Case Diagram).


View schema

A view schema (or simply a view) is a schema that is derived from another source schema. It includes a subset of the constructs of the latter. Every component of a view can be renamed, transformed and moved in the graphical space, but no object can be added or deleted. Any update on the source schema can be propagated down to its views. A view can be derived from another view.

Entity types, relationship types, attributes and collections of data schemas, action states, object states, control flows and data flows of UML activity diagrams, use cases, actors and relations of UML use case diagrams have a meta-property giving the list of views in which they take part.

An attribute is included in a view if its parent is too. A group takes part into a view if all its components do as well. A role is included in a view if its relationship type and all its entity types are included too.

Notes are not included in views.

How to use views in the DB-MAIN environment

View definition

Defining a view is a two-step process:

1.

All the objects that belong to the view (entity types, relationship types, attributes, collections, action states, object states, control flows, object flows, use cases, actors and relations between use cases and actors) must be marked

2.

The Product/View/Define view... command must be called. The View dialog box displays the list of already existing views. A name must be given to the new one and the OK button defines the view. Every marked object is thus copied to the new view.

At this point, the view itself is not yet represented by a schema. A generation process is required to embody it in a schema.

Generation

The Product/View/Generate view... command allows to generate a view. A dialog box displays the list of the views defined on the current schema. Select a view and click on the OK button to embody the view in a schema. If Include attributes is checked, all attributes of the objects marked during the view definition step are also copied, otherwise only those that were specifically marked are copied. If Include processing units (view of a data schema) is checked, all processing units of the objects marked during the view definition step are also copied, otherwise only those that were specifically marked are copied. If Include relations is checked, control flows and data flows (in UML activity diagrams) or relations between actors and use cases (in UML use case diagrams) are copied too, otherwise only those marked during the view definition step are copied. In data schema views, an object attribute is copied only if the referenced object is copied.

If a view is generated for the first time, the process just copies the objects marked during the view definition step. If the view already exists, its log is replayed on the generated view. In particular, it allows to move the objects of the view and keep the new positions after each new generation.

Mark the objects of a view

The Product/View/Mark view... command allows to mark in the source schema all the objects that were previously defined as members of a view. It can be useful to modify the definition of a view.

View handling

The Product/View/Rename view..., Product/View/Copy view... and Product/View/Remove view... commands allow respectively to rename, copy and delete a view.

Note

Schema view generation and deletion can only be performed when the current view of the project is the graphical standard one.


User-defined domain

User-defined domains

A user-defined domain can be atomic or compound, it can be associated with several attributes (in the attribute properties dialog box, select user-defined type in the type combo-box and then the user-defined domain in the new combo-box). A user-defined domain is defined for the current project.

The User-defined domains dialog box

The action buttons of the user-defined domains dialog box are described below:

New | : to create a new user-defined domain;
Modify | : to modify the selected user-defined domain;
Remove | : to delete the selected user-defined domain;
Close | : to close the dialog box saving changes;
Report | : to generate a text file containing the description of user-defined domains;
Move Up | : to swap the selected user-defined domain with the previous one;
Move Dwn | : to swap the selected user-defined domain with the next one;
Help | : to get help information on user-defined domains.

The User-defined domain property dialog box

The properties of user-defined domains are the same as those of attributes (with some restrictions). A user-defined domain has the following features:

Name

: to give a name to the domain (mandatory, 100 characters);

Short name

: to give a short name to the domain (optional, 12 characters);

Cardinality

:

to set the minimum and maximum cardinalities (mandatory, 0 min < N, min max and 1 max N);

Collection type

:

to select a collection type (set, bag, unique list, list, unique array, array) (for multivalued domains only);

Type

: to select a type (numeric, char, date, boolean, compound, float, varchar or object type);

Stable

:

if checked, the value of attributes of this domain cannot be changed;

Non Recyclable

:

if checked, the value of attributes of this domain cannot be reused;

Length

: to set the length of attributes of the domain (only for numeric-based and char-based domains);

Decim

: to set the length of the decimal part (only for numeric-based domains);

User-def

:

to select the user-defined domain (only for user-defined type based on another user-defined type);

Sem

: to give a semantic description to the domain;

Tech

: to give a technical description to the domain;

Prop

: to give value(s) to the meta-properties of the domain.

Exit buttons

Ok

: to close the dialog box saving changes;

Cancel

: to close the dialog box discarding changes.


The New menu

N ew menu

The New menu allows to add new objects to the current schema.

Collection... | to create a new collection;
Entity type... | to create a new entity type (interactive or from a COBOL source text);
Rel-type... | to create a new rel-type;

Attribute

to add a new attribute (interactive or from a COBOL source text)

First... | as first child of the current parent object, or
Next... | as next sibling of the current attribute;
Role/rel-type... | to add a new role to the current relationship type or a rel-type between two entity types;
Group... | to add a new group (primary/secondary id, access key, coexistence, ...) to the current object;
Constraint... | to add a new constraint to the current group;
Processing unit... | to add a new processing unit to the current schema, rel-type or entity type.
__________
Action state... | to create a new action state;
Initial state... | to create a new initial state;
Final state... | to create a new final state;
Horizontal synchronization... | to create a new horizontal synchronization bar;
Vertical synchronization... | to create a new vertical synchronization bar;
Decision... | to create a new decision;
Object... | to create a new internal object;
State... | to create a new object state;
Signal sending... | to create a new signal sending;
Signal receipt... | to create a new signal receipt;
Control flow... | to create a new control flow;
Object flow... | to create a new object flow.
__________
Use case... | to create a new use case;
Actor... | to create a new actor;
Extend relationship... | to create a new extend relationship;
Include relationship... | to create a new include relationship;
Use cases generalization... | to create a new use case generalization relationship;

Association...

to create a new association relationship;

Actor generalization...

to create a new actor generalization relationship.

__________

Note... | to add a new note to the current object(s) (if any) or to the current schema;
Link note... | to link a note to another object.

See also:

Creation.


Object creation

Creation

Objects can be created using the New menu, except for products (Product menu) and projects (File menu). Most objects (entity types, rel-types, first and next attributes, roles, identifiers, groups, collections, notes, processing units, action states, use cases, objects, various relationships and actors) can also be created with the standard tool palette.

In textual views of schemas (ER, UML Class, Activity or Use Case Diagram):

When a “new…” menu item or a toolbar button is selected, the corresponding dialog box appears, thus allowing to modify the default properties.

In graphical views of data schemas:

To create an entity type (or a rel-type or a collection), enter the appropriate creation mode (New menu or tool bar buttons). As a result, the pointer shape changes and an entity type (respectively a rel-type or a collection) is created where the mouse is pointing every time you press the mouse button.

To create a role, enter the role creation mode (New/Role or the appropriate tool bar button), click on an entity type (or a rel-type) and drag the mouse pointer to a rel-type (or an entity type). To create a multi-ET role, click on the role (or entity type) and drag the mouse pointer to an entity type (or role).

To exit a creation mode, click a second time on the button in the tool bar, press the ESC key or click on another creation button.

To create a note, enter the note creation mode (New/Note or the appropriate tool bar button). The pointer shape changes and a note is created where the mouse is pointing when its button is pressed. The note creation mode is left automatically. If the selected objects are entity types, rel-types, attributes, groups, collections or processing units, the note is linked to these objects. Otherwise the note belongs to the schema as a whole. A note can be attached to more objects later on. To do this, enter the note link creation mode (New/Note link or the appropriate tool bar button) and drag the mouse pointer from a note to another object (or conversely).

To create an attribute of the selected parent (entity type or rel-type), call the Attribute properties dialog box (New/Attribute (/First att… or /Next att…) or the appropriate tool bar button) and enter the attribute properties.

To create a first child attribute of the selected attribute (in order to create a compound attribute), call the Attribute properties dialog box (New/Attribute/First att…) menu item or the appropriate tool bar button) and enter the attribute properties.

To create a sibling attribute of the selected attribute, call the Attribute properties dialog box (New/Attribute/Next att…) menu item or the appropriate tool bar button) and enter the attribute properties.

To create an identifier made up of the selected attribute(s) and/or role(s), click on the ID button in the tool bar.

To create a group made up of the selected attribute(s) and/or role(s), click on the GR button in the tool bar.

In graphical views of UML Activity and Use Case Diagrams:

To create an action state (or an internal object), enter the appropriate creation mode (New menu or tool bar buttons). As a result, the pointer shape changes and an action state (respectively an internal object) is created where the mouse is pointing every time you press the mouse button.

To create a relation (control flow, object flow, use case generalization, use case extension, use case inclusion, actor association or actor generalization), enter the appropriate creation mode (New menu or tool bar buttons), click on the source diagram element and drag the mouse pointer to the target diagram element.

To exit a creation mode, click a second time on the button in the tool bar, press the ESC key or click on another creation button.

To create a note, enter the note creation mode (New/Note or the appropriate tool bar button). The pointer shape changes and a note is created where the mouse is pointing when its button is pressed. The note creation mode is left automatically. If the selected objects are action states, objects, use cases, actors or relationships between use cases and actors, the note is linked to these objects. Otherwise the note belongs to the schema as a whole. A note can be attached to more objects later on. To do this, enter the note link creation mode (New/Note link or the appropriate tool bar button) and drag the mouse pointer from a note to another object (or conversely).

To create an attribute of the selected parent (object), the parent of a sibling attribute should be double-clicked to open its property box and the first or next button should be pressed to open a new creation dialog box.

To create an attribute of the selected object, double-click on the object to open its state property box, choose the Object button and push the First att. or Next att. button to open the attribute creation dialog box.

In graphical views of projects (standard or dependency):

To create a new schema, select the Product/New schema menu item.

To add a text file to a project, select the Product/Add text menu item or drag and drop a file icon in the project window.

To create a note, enter the note creation mode (New/Note or the appropriate tool bar button). The pointer shape changes and a note is created where the mouse is pointing when its button is pressed. The note creation mode is left automatically. If the selected objects are schemas, text files, primitive processes, engineering processes or sets, the note is linked to these objects. Otherwise the note belongs to the project as a whole. A note can be attached to more objects later on. To do this, enter the note link creation mode (New/Note link or the appropriate tool bar button) and drag the mouse pointer from a note to another object (or conversely).

In the Education version, primitive and engineering processes can be created through the Engineering menu or the Process modeling tool palette. To create a primitive process that can update products, select the products to update and call the New primitive process tool. To create an engineering process, select input products and call the New engineering process tool. When such a process is finished, select output and updated products and call the End engineering process tool. To make a decision, select all alternatives and call the Decision tool.

In the other versions, when carrying out a project without using a method, primitive and engineering processes can be created through the Engineering menu or the Process modeling tool palette. To create a primitive process that can update products, select the products to update and call the Use primitives or the Copy schema and use primitives tool. When the process is finished, call the End use of primitives tool. To create an engineering process, select input products and call the New engineering process tool. When such a process is finished, select output and updated products and call the End engineering process tool. To make a decision, select all alternatives and call the Decision tool. When using a method, the creation of processes is normally managed by the methodological engine, but more processes can be created manually.

In the text browser:

If the current window is a source text browser displaying a COBOL source file and if the current line is a "PIC clause", the following actions can be carried out:

- | create an entity type that takes the name of the variable declared in the "PIC clause" (New/Entity type menu item);
- | add a first attribute to the selected object; this attribute takes the properties of the variable declared in the "PIC clause" (New/Attribute/First att… menu item);
- | add a new attribute to the selected object; this attribute takes the properties of the variable declared in the "PIC clause" (New/Attribute/Next att… menu item).


The Transfo menu

T ransform menu

The Transform menu allows to perform transformations (most of them are semantics-preserving) on the current object. In the future, this toolbox will be expanded according to the needs of various database engineering activities. The current functions make it possible to carry out such activities as, for instance,

- | the production of most relational, CODASYL, standard files, IMS, TOTAL/IMAGE, (and the like) databases,
- | some optimizations of database schemas,
- | conceptual restructuring,
- | reverse engineering.
Entity type | to transform the current entity type
-> Rel-type | ... into a rel-type;
-> Attribute | ... into an attribute.
__________
Is-a -> rel-type | to transform the is-a relation(s) of the current entity type into one-to-one relationship type(s);
Rel-types -> is-a | to transform one-to-one relationship type(s) of the current entity type into is-a relation(s).
__________
Split/Merge | to split the current entity type into two entity types or merge two entity types linked by a one-to-one relationship type;
Add Tech ID | to add a technical primary id to the current entity type.
Rel-type | to transform the current rel-type
-> Entity type | ... into an entity type;
-> Attribute | ... into a reference attribute (foreign key);
__________
-> Object att. | ... into an object type attribute.
Attribute |
-> Entity type | to transform the current attribute into an entity type:
instance representation | to represent all instances of the attribute,
value representation | to represent all distinct values of the attribute;
Disaggregation | to replace a compound attribute with its components;
__________
Multi -> Single | to transform a multivalued attribute into a single-valued one;
Single -> Multi | to transform a single-valued attribute into a multivalued one;
Multi -> List Single | to transform a multivalued attribute into a list of single-valued ones;
Multi Conversion | to change the collection type of the current attribute (with or without loss).
__________
Domain Materialization | to replace the user-defined domain of the current attribute with its definition.
__________
Object att. -> Rel-type | to transform an object type attribute into a rel-type.
Role |
Multi-ET -> rel-types | to transform a multi-ET role into a set of rel-types.
Group |
-> Rel-type | to transform a reference group (foreign key) into a rel-type;
Aggregation | to transform the components of a group into a compound attribute;
__________
-> Multi-valued | to transform a group of single-valued attributes into a multivalued attribute.
__________
Change prefix ... | to detect the largest prefix of the components of the selected object and allow its substitution by a new prefix;
Name processing ... | to process the names of the selected objects.
__________
Relational model | to replace (through transformations) the current schema with its relational physical version (without optimization).
__________
Quick SQL... | to generate a simple SQL program that includes the relation structures corresponding to the current schema.

See also:

Transformations, elementary transformations, generation.


Name processing

The name processor allows to transform the names and short names of all objects (entity types, rel-types, attributes, roles, groups, processing units and collections) of a schema. For instance, it is used to make the names compliant with a database model. It may also be useful in reverse engineering activities.

Actions

Scope: to define the scope of the process (which objects, which names);

Substitution patterns: to define substitution patterns (list of "old string new string");

Change case, Capitalize and Remove accents: to perform additional specific actions;

Shorten: to shorten names according to a specified number of characters;

Load/Save substitution patterns: to save/load substitution patterns (files with a .pat extension).

Wildcards in search strings

?

matches any single character;

*

matches any sequence of characters (zero or more);

^

represents the line start;

$

represents the line end;

Wildcards are not allowed in the replacement string

Examples:

Let 'elephant' be the name to process and 'XXX' the replacement string,

search | result
leph | eXXXant
e | XXXlXXXphant
e? | XXXXXXhant
l*h | eXXXant
*p | XXXhant
p* | eleXXX
e* | XXX
* | XXX
^e | XXXlephant
t$ | elephanXXX
e$ | elephant
^e*p?a*t$ | XXX

When several transformations have to be executed, they are performed in the following order:

-1- | pattern matching;
-2- | removal of accents;
-3- | case conversion;
-4- | shortening.


Model-based transformations

A model-based transformation allows to apply all necessary transformations to the objects of a schema in order to transform it into a schema that complies with a specific model. In this version, only the physical standard relational model is proposed.

A schema is compliant with the relational model if:

- | There are no is-a relations.
- | There are no rel-types.

-

All entity types have at least one attribute.

-

All attributes are atomic and single-valued.

- | There are only two kinds of constraints: identifiers and referential constraints.
The transformation script used to make a schema compliant with the relational model is described below:
- | Transform of is-a relations into rel-types.
- | Transform all complex and binary many-to-many rel-types into entity types.
- | Split multi-ET roles into rel-types.
- | Convert user-defined attributes
- | While there are multivalued and/or compound attributes:
- | transform multivalued attributes into entity types,
- | disaggregate of compound attributes.
- | Rename groups
- | Transform binary one-to-many rel-types into referential attributes.
- | Create access keys for identifiers and referential constraints (without making prefix access keys).
- | Rename objects to remove non SQL-standard characters.
If the preconditions of some transformations are not satisfied, this strategy may fail and produce an incompletely processed result.

See also:

Elementary transformations


The Assist menu

A ssist menu

The Assist menu offers a set of expert assistants dedicated to specific classes of problems.

Global transformation ... | to perform selected actions on selected objects in order to solve structural problems. For each outstanding class of constructs (the problem), this assistant suggests one or several transformations that can replace them with equivalent constructs (the solution) or simply mark or unmark the selected constructs. This assistant offers other additional global functions.
Advanced Global Transformation ... | to perform advanced actions on filtered objects in a structured way (not available in the Education version).
__________
Schema Analysis ... | to analyze the current schema and validate it according to specified constraints (not available in the Education version).
__________
Integration
Schemas ... | to integrate a data schema into the current one;
Objects ... | to integrate two semantically identical objects (entity types, rel-types or compound attributes).
__________
Rel. physical design |
Oracle… | to add some physical information into the meta-properties used by the parametric SQL generator for Oracle (see the File/Generate menu). This program is written in Voyager 2.
 | (not available in the Education version)
__________
Text analysis | to analyze source texts (not available in the Education version).
Load pattern ... | to load and edit pattern files;
__________
Search ... | to search a text for the first instance of a given pattern;
Search next | to search a text for the next instance of a given pattern;
__________
Execute ... | to execute a V2 function, taking the variables of a pattern as parameters;
Dependency ... | to build the dependency graph of all variables of the source program;
__________
Program slicing ... | to compute the slice corresponding to the selected line and color the result;
Mark slice | to mark the lines belonging to the last computed slice;
Slicing assistant | to compute automatically several slices within the same source code;
Dependency/SDG | to display the variables that depend on the selected one;
Load / save |
Load SDG | to load the System Dependency Graph of the current text;
Save SDG | to save the System Dependency Graph of the current text;
Load parsing | to load the parsing tree of the current text;
Free structure | to free the parsing tree and System Dependency Graph of the current source file;
__________
Settings | to set some configuration options for the Text analysis assistant;
Clear color | to color black the program slice and the dependency graph;
__________
Goto | when a logical schema and its source text are both visible, the origin source text line of the selected object is highlighted and conversely.
Referential key ... | to find groups that could be connected to the current one (not available in the Education version).


The Log menu

L og menu (Not available in the Education version)

The Log menu allows to record performed actions and to replay them selectively.

Trace | to enable/disable the recording of user actions in the current schema log;
Add check point... | to insert a checkpoint label in the current schema log;
Add schema... | to insert an image of the current schema in its log;
Add desc... | to insert a free text message in the current schema log.
__________
Clear log | to erase the current schema log;
Save log as... | to save the current schema log to a file.
__________
Replay | to replay selected actions recorded in a log file (schema copies and messages are ignored) on the current schema:
Automatic... | to replay a complete section (bounded by two checkpoints) of a log file;
Interactive... | to replay actions recorded in a log file in a selective way.

See also:

Log, replay, save log, configuration.


Log

Presentation of the log

Logs allow to record all actions carried out by the analyst, and replay them in a selective way. They are recorded into the schemas.

The log management performs the following actions:

- | it records all actions carried out on schemas;
- | it allows users to replay all recorded actions or some of them;
- | it has a both formal and readable syntax;
- | there is one log per schema;
- | it references (check points) the processes that update the schema;
- | it allows to undo the last command.
See also : Recording to a log file, Replay a log file


Recording into a log file

Save a log file

A log is associated with each schema and is saved in the .lun file of the project.

The Log/Trace menu command allows to start and stop the recording of a log.

The Log/Save log as command allows to save the log of the current schema to a file

The Log/Add check point… menu command allows to insert special named records into schema logs.

These records allow analysts to mark the log in order to describe significant events (end of normalization, end of translation, etc.). Check points are used by the replay function. Two default check points are inserted: at the beginning (begin-file) and at the end (end-file) of the schema log. Other ones are placed at the beginning or end of a process.

Two different kinds of comments can be inserted into schema logs:

- | an image of the current schema (Log/Add schema) (useful for slides and case studies !);
- | an arbitrary text (Log/Add desc...).

These comments are ignored during the REPLAY process.

See also : Presentation of the log, Replay a log file


Replay

Replay a log file

The replay process allows to replay the actions recorded into a log file on the current schema.

To identify an object, the replay process uses its name (prefixed by the name of its parent). Thus, to replay a log-file, the current schema must contain objects that have the same name as those stored in the log file:

- | Log/Replay/Automatic...
To replay a complete section (bounded by two selected check points) of the log file.
- | Log/Replay/Interactive...
The next record to be executed is displayed into the dialog box. The available actions are described below:
Skip to refuse the execution of the recorded action and display the next one;
Step to execute the recorded action and display the next one;
Stop to stop the replay process;
Goto to jump to the selected check point without executing any action;
Continue to execute all recorded actions up to the selected check point.
See also : Presentation of the log, Recording to a log file


The Engineering menu

Engineering menu (Not available in the Education version)

The Engineering menu allows to manage processes and their histories.

Use primitives | to update the selected products with the help of primitive functions;
Copy schema & use primitives | to make a copy of the the selected schema and update the copy with the help of primitive functions;
End use of primitives | to stop using primitives.
__________
New engineering process | to create a new engineering process using selected products as input/for update;
End current process | to terminate the current engineering process using selected products as output.
__________
Continue process | to resume a terminated process.
__________
Take decision | to decide which products must be kept/abandoned.
__________
Properties | to display the properties of the selected process;
Edit input/output/update products | to change input, output and update products for the selected process.
__________
Control | to adapt the level of control of user actions according to the methodology or history coherence.

See also:

Structured history.

History menu (Education version only)

The History menu allows to manage processes and their histories.

New primitive processs | to create a new primitive process updating the selected products in the current process view;
New engineering process | to create a new engineering process using selected products as input/for update;
End current process | to terminate the current engineering process using selected products as output;
New decision | to decide which products must be kept/abandoned.
__________
Properties | to display the properties of the selected process;
Edit input/output/update products | to change input, output and update products for the selected process.

See also:

Structured history.


Engineering method

An engineering method allows to carry out a project following a specific process. Associating such a method to a project is optional. The method can be displayed in a window (View/Engineering method) and it is possible to browse through it. The analyst can refer to it any time.

Engineering methods must be written in MDL (Method Description Language) and compiled with the external MDL compiler to produce a *.LUM file. This file can be associated to the project at creation time (File/New project menu item). If no method is specified, the default one allows to do anything.

See also: Method window.


Structured history

The history of a database engineering process contains the trace of all the activities performed, all the products involved, all the hypotheses put forward, all the versions of the products resulting from those hypotheses as well as all the decisions made. Obviously, the result is a complex graph.

The first basic elements of a history are processes. A history contains all the processes that are performed during an engineering activity. The whole project is made of processes divided into sub-processes and so on. Since a process is made of several sub-processes, it is useful to know their order of execution, i.e., serially or in parallel. So each process is stamped with its beginning date and time (mandatory) and end date and time. Processes can thus be identified by their name and begin time stamp. In order to document their work, analysts can add a description (in free text) to each process. There are two kinds of processes: primitive processes and engineering processes.

A primitive process uses only primitives (built-in functions of the CASE tool or external functions written in Voyager 2). The execution of primitives can be recorded in a log file.

An engineering process follows a strategy: the analyst can make hypotheses, try various solutions and decide to abandon some of them. The history of an engineering process is a graph displayed in the project window.

Hence, the whole history is in fact a tree of graphs; leaf nodes are primitive processes with their log files or engineering processes under way and non-leaf nodes are engineering processes.

The second basic elements of a history are products. They are identified by their name and their version. Again, they can be given some descriptions. A product can be the result of several processes, but, at some point, it must be declared finished. From that moment on, this product is locked (a small lock is displayed on top of it in the project window). It is no longer allowed to modify it. Hence, each product has a locked/ unlocked state.

Finally, the third basic elements of a history are decisions. A decision is a special kind of process that does not alter or generate any product. A decision follows hypotheses. When an analyst has to perform a process, (s)he can put forward various hypotheses and repeat the same process several times according to one hypothesis or another. The description of each process contains the chosen hypothesis. Each process generates its own version of the products. When all the processes are over, the analyst chooses one version to go on with his/her work. The decision process represents the choice with a double headed arrow and its description contains the rationales that have led to that choice.

In practice

          •

    If menu Engineering/Controlled history is checked, the actions that can be performed are strictly controlled: it is not possible to modify a locked product or a product on which no process is active. On the other hand, if this option is not checked, the user has more freedom, but history coherence and reusability cannot be guaranteed.

  • If the controlled history mode is on, it is necessary to begin a process (menu Engineering/use primitives) in order to be allowed to update a product.

  • To begin an engineering process, first select all the products you want to use as input or for update, and then call the engineering/new engineering process menu command.

  • To begin a primitive process, first select all the products you want to use as input or for update, and then call the engineering/use primitives menu command.

  • To terminate a primitive process, select it and call the engineering/end use of primitives menu command.

  • To terminate an engineering process, make sure that all its sub-processes are finished and then select all the products you want to use as output and call the engineering/end current process menu command.

  • The engineering/continue process menu command allows to resume a previously stopped process.

  • To browse through the history, double click on an engineering process to view it or click on the X button at the top right corner of the window to view its parent (clicking on that button in the root engineering process window (i.e. the project window) closes the project).

  • The window/process hierarchy menu command allows to browse through the history as well.

  • A product can be locked/unlocked manually via the product/lock/unlock menu command.


The View menu

V iew menu

Text standard and Graph. standard views can also be accessed through the standard tool box.

Text compact | to display the compact textual representation of data schemas, UML activity diagrams and UML use case diagrams;
Text standard | to display the standard textual representation of data schemas, UML activity diagrams and UML use case diagrams;
Text extended | to display the extended textual representation of data schemas, UML activity diagrams and UML use case diagrams;
Text sorted | to display the sorted textual representation of data schemas, UML activity diagrams and UML use case diagrams;
Graph. compact | to display the compact graphical representation of data schemas and projects;
Graph. standard | to display the standard graphical representation of data schemas, UML activity diagrams, UML use case diagrams and projects;
Graph. dependency | to display the dependency graphical representation of projects.
__________
Second window | to open a second window of the same schema. If the current window is graphical, the new one will be textual, and conversely.
__________
Graphical settings | to set graphical options for the current window (graphical views);
Alignment | to align the selected objects so as to …
Left | … place their left border on the left edge of the rectangle formed by their external edges;
Right | … place their right border on the right edge of the rectangle formed by their external edges;
Horizontal center | to move the selected objects horizontally to the center of the rectangle formed by their external edges;
Horizontal space equal | to move the selected objects horizontally and space them evenly within the rectangle formed by their external edges;
__________
Top | … place their top border on the upper edge of the rectangle formed by their external edges;
Bottom | … place their bottom border on the lower edge of the rectangle formed by their external edges;
Vertical center | to move the selected objects vertically to the center of the rectangle formed by their external edges;
Vertical space equal | to move the selected objects horizontally and space them evenly within the rectangle formed by their external edges;
__________
Horizontal square | to align horizontally the roles of the selected rel-types with their rel-type. If a rel-type is cyclic, its first role is aligned horizontally and the other one vertically;
Vertical square | to align vertically the roles of the selected rel-types with their rel-type. If a rel-type is cyclic, its first role is aligned vertically and the other one horizontally;
Top square | to move the selected non-cyclic rel-types to an upper corner of the rectangle formed by the external edges of their associated entity-types;
Bottom square | to move the selected non-cyclic rel-types to a lower corner of the rectangle formed by the external edges of their associated entity-types.
UML role positioning | to place the name and cardinalities of the selected roles or rel-types…
Top left | … above and to the left of the role or rel-type position;
Top center | … above the role or rel-type position;
Top right | … above and to the right of the role or rel-type position;
Center left | … to the left of the role or rel-type position;
Center | … precisely at the role or rel-type position;
Center right | … to the right of the role or rel-type position;
Bottom left | … below and to the left of the role or rel-type position;
Bottom center | … below the role or rel-type position;
Bottom right | … below and to the right of the role or rel-type position;
Automatic positions | … at the best position (avoiding lines).
Move schema | toggles on/off the schema moving mode; in that mode, the cursor is changed to a hand, clicking and dragging will move the schema in its window; this is a faster way than using the slide bars for browsing through large schemas.
Auto-Draw | in a graphical view of a data or processing schema: to get a new graphical layout of the current schema (useful in reverse engineering). Since the new layout is semantics-independent and no undo function is available, this function must be used cautiously. This function is a stochastic process, i.e. a new call gives a new layout.
__________
Engineering method | to display a window containing the current engineering method (not available in the Education version)

See also:

Textual data schema window, Graphical data schema window, Textual UML Activity Diagram window, Graphical UML Activity Diagram window, Textual UML Use Case Diagram window, Graphical UML Use Case Diagram window, Graphical project window.


Graphical settings

The Graphical settings dialog box displays a set of configuration options to apply to the current graphical view. The set of available options depends on the current window. In the following list, options marked with (1) apply to data schemas, those marked with (2) apply to UML Activity Diagram, those marked with (3) apply to Use Case Diagrams, and those marked with (4) apply to processes.

Independent(1,2):

If checked, each object can be moved independently; moving one or several objects has no effect on the rest of the schema. If not checked, when some selected objects are moved, some objects connected to them are moved too:

- clusters and recursive rel-types always keep the same distance from the entity type that hosts them. So, when entity types are moved, connected clusters and recursive rel-types are moved exactly the same way.

- some objects are proportionally moved in order to keep the same relative position in relation to other objects. Given an object A that is positioned at two thirds of the distance between two other objects, when one of these two objects is moved, A is automatically moved so that it is still at two thirds of the distance between the other ones. The situations in which this rule is applied are listed below:

Selected object that is moved | Objects connected but not selected that are moved proportionally
Entity type:(1) | non-recursive rel-types, roles played by the entity type, other roles of the connected rel-types.
Rel-type:(1) | roles.
Action state:(2) | control flows, object flows.
Use case:(3) | use case extensions, use case inclusions, use case generalizations, use case-actor associations.
Internal or external data-object state:(2) | control flows, object flows.
Actor:(3) | use case-actor associations, actor generalizations.

- notes are moved if all the objects to which they are linked are moved together (selected or dependent on a selected one). Otherwise, notes stay where they are.

Important: All selected objects are moved the same way (same direction, same distance) as the pointed one.

Zoom(1,2,3,4): | To shrink or expand the graphical representation of the current schema or project. The user can choose a percentage (>= 10 and <= 999). The fit option automatically selects the best factor to display the whole schema in the window.
Reduce(1,2,3,4): | To shrink or expand the graphical representation of the current schema or project. The user can choose a percentage (>= 10 and <= 999). The chosen factor is kept when sending the schema to a printer or copying it to the clipboard.
Grid(1,2,3,4): | To draw a grid in the current schema or project window. The user can either specify the grid width and length manually or choose a predefined option. The Default printer option allows to draw a grid that is the size of the printing area of the current printer.
Show relations(2,3) | To choose to display or not various kinds of relations:
 | - in UML Activity Diagrams: control flows and object flows;
 | - in Use Case Diagrams: extend and include relations, use case generalizations, associations and actor generalizations.
Show objects(1,2,3,4): | To choose whether to display or not various kinds of objects:
 | - in data schemas: attributes, primary identifiers, other groups, processing units, notes, attribute types and stereotypes;
 | - in UML Activity Diagrams and Use Case Diagrams: notes and stereotypes;
 | - in process windows: new schema and add text processes.
ISA square(1) | : if checked, is-a relations are drawn with horizontal and vertical lines.
Entity type shape(1) | : to choose the graphical look of entity types (square or round corners).
Entity type shade(1) | : If checked, entity types are shaded.
Rel-type shape(1) | : to choose the graphical look of rel-types (with square or round corners).
Rel-type shade(1) | : If checked, rel-types are shaded.


The Window menu

W indow menu

The Window menu allows to manage windows and toolbars.

Most windows opened from this menu are provided with all standard window elements, such as scroll bars, Minimize and Maximize buttons, and a Control menu box.

The bottom of the Window menu displays the list of currently open windows. This list can be used to switch from one window to another.

Standard tools | to show/hide the Standard tool palette;
Graphical tools | to show/hide the Graphical tool palette;
UML role position tools | to show/hide the UML role positioning tool palette;
RE tools | to show/hide the Reverse Engineering tool palette (not available in the Education version);
Transfo tools | to show/hide the Transformation tool palette;
Process tools | to show/hide the Process modeling tool palette;
User tools | to show/hide the corresponding u+ser-defined tool palette:
User tools 1 |
User tools 2 |
User tools 3 |
User tools 4 |
User tools 5 |
User tools 6 |
User tools 7 |
User tools 8 |
User tools 9 |
User tools 10 |
__________
Property box | to show/hide the property box (non-editable) of the current object;
Process hierarchy | to show/hide the process hierarchy tree;
Status bar | to show/hide the status bar.
__________
Tile | to tile non-minimized windows on the desktop;
Cascade | to cascade non-minimized windows on the desktop;
Arrange Icons | to arrange minimized windows;
Close All | to close all open windows.
__________
1 window name | to select the first window;
2 window name | to select the second window;
etc | ...


Property box

The property box is a small non-editable window displayed on top of the others. It contains all the properties of the last selected object and is divided into three tabs:

 | The properties tab lists all the properties of the object: static built-in properties first and then meta-properties;
 | The semantics tab displays the semantic description of the object (if any). It can also show the description (if any) of the objects that can have only one description (processes for instance);
 | The technical tab displays the technical description of the object (if any).
When a note is selected this window has only one tab that displays the content of the note.


The Help menu

H elp menu

The Help menu gives access to the Help system, which is displayed in a special window. The Help system provides information on virtually all aspects of DB-MAIN.

Help | F1 | to display the table of contents of the help system.
First steps |  | to open a short tutorial.

About DB-MAIN...

to display version, copyright, contact and other DB-MAIN information.


The standard tools palette

Standard tool palette

 | to build a new project;
 | to open an existing project;
 | to save the current project (*.lun file);
 | to save the current project as a new *.lun file, *.isl file or *.xml file;
 | to save a copy of the current schema (in data schema views) (not available in the Education version);
 | to run a compiled Voyager 2 program (*.oxo file) (not available in the Education version);
 | to resume an interrupted Voyager 2 program (not available in the Education version);
 | to execute once more the most recently used (if any) Voyager 2 program without loading it again (not available in the Education version);
 | to get a quick SQL DDL code corresponding to a conceptual schema (through a background transformation of this schema into the relational model followed by SQL code generation) (Education version only).
See also: File menu.
 | to display the standard textual representation of the current data schema;
 | to display the standard graphical representation of the current data schema.
 | togle on/off the fast scroll mode for browsing through large schemas.
See also: View menu, Edit menu.
The following buttons are only visible when the current window displays a data schema:
 | to create a new entity type (interactive or from a COBOL source text);
 | to create a new rel-type;
 | to add a new attribute as first child of the current parent object;
 | to add a new attribute as next sibling of the current attribute;
 | to create a new role or a rel-type between two entity types;
 | to create a new identifier composed of the selected attributes and/or roles;
 | to create a new group composed of the selected attributes and/or roles;
 | to create a new collection;
 | to add a new processing unit to the current schema, rel-type or entity type.
See also: Creation, New menu.
The following buttons are only visible when the current window displays a UML Activity Diagram
 | to create a new action state;
 | to create a new initial state;
 | to create a new final state;
 | to create a new horizontal synchronization bar;
 | to create a new vertical synchronization bar;
 | to create a new decision;
 | to create a new internal object;
 | to create a new state;
 | to create a new signal sending;
 | to create a new signal receipt;
 | to create a new control flow;
 | to create a new object flow.
See also: Creation, New menu.
The following buttons are only visible when the current window displays a UML Use Case Diagram:
 | to create a new use case;
 | to create a new actor;
 | to create a new extend relationship between two use cases;
 | to create a new include relationship between two use cases;
 | to create a new generalization relationship between two use cases;
 | to create a new association relationship between a use case and an actor;
 | to create a new generalization relationship between two actors.
See also: Creation, New menu.
 | to add a new note to the selected object(s) (if any) or to the current schema;
 | to link a note to an object;
 | to examine / modify the semantic description of the current object;
 | to examine / modify the technical description of the current object;
 | to examine / modify the values of meta-properties associated to the current object.
See also:Semantic and technical descriptions, meta-property.
 | to color the selected objects;
 | to mark / unmark the selected objects;
 | to select a marking mode;
See also:Edit menu.


The graphical tools palette

Graphical tool palette

 | if checked, each object can be moved independently; otherwise all the objects connected to the selected one(s) are moved together with it;
 | to copy the graphical representation of the selected objects to the clipboard;
 | to expand the graphical representation of the current schema or project (current factor + 10%);
 | to shrink the graphical representation of the current schema or project (current factor - 10%);
 | to shrink or expand the graphical representation of the current schema or project (by setting a percentage or choosing the “fit” option).
See also: Graphical settings, Edit menu.
 | to align the selected objects so as to place their left border on the left edge of the rectangle formed by their external edges;
 | to align the selected objects so as to place their right border on the right edge of the rectangle formed by their external edges;
 | to move the selected objects horizontally to the center of the rectangle formed by their external edges;
 | to move the selected objects horizontally and space them evenly within the rectangle formed by their external edges;
 | to align the selected objects so as to place their top border on the upper edge of the rectangle formed by their external edges;
 | to align the selected objects so as to place their bottom border on the lower edge of the rectangle formed by their external edges;
 | to move the selected objects vertically to the center of the rectangle formed by their external edges;
 | to move the selected objects vertically and space them evenly within the rectangle formed by their external edges;
 | to align horizontally the roles of the selected rel-types with their rel-type;
 | to align vertically the roles of the selected rel-types with their rel-type;
 | to move the selected non-cyclic rel-types to an upper corner of the rectangle formed by the external edges of their associated entity-types;
 | to move the selected non-cyclic rel-types to a lower corner of the rectangle formed by the external edges of their associated entity-types.
See also: View menu.


The UML role positioning tools palette

UML role position tool palette

to place the name and cardinalities of the selected roles or rel-types above and to the left of the role or rel-type position;

to place the name and cardinalities of the selected roles or rel-types above the role or rel-type position;

to place the name and cardinalities of the selected roles or rel-types above the role or rel-type position;

to place the name and cardinalities of the selected roles or rel-types to the right of the role or rel-type position;

to place the name and cardinalities of the selected roles or rel-types below and to the right of the role or rel-type position;

to place the name and cardinalities of the selected roles or rel-types below the role or rel-type position;

to place the name and cardinalities of the selected roles or rel-types below and to the left of the role or rel-type position;

to place the name and cardinalities of the selected roles or rel-types to the left of the role or rel-type position;

to place the name and cardinalities of the selected roles or rel-types precisely at the role or rel-type position;

to place the name and cardinalities of the selected roles or rel-types at the best position (avoiding lines).

See also:

View menu.


The reverse engineering toolbox

Reverse engineering tool palette

 | to search a text for the first instance of a given pattern;
 | to search a text for the next instance of a given pattern;
 | when a logical schema and its source text are both visible, to highlight the origin source text line of the selected object and conversely;
 | to compute the slice that corresponds to the selected line and color the result;
 | to find groups that could be connected to the current one (Not available in the Education version).
See also: Assist menu, search pattern, goto, program slicing, referential key.


The transformations toolbox

Transformation tool palette

Entity type

-> Rel-type | to transform the current entity type into a rel-type;
-> Attribute | to transform the current entity type into an attribute;
Is-a -> rel-types | to transform the is-a relation(s) of the current entity type into one-to-one relationship type(s);
Rel-types -> is-a | to transform one-to-one relationship type(s) of the current entity type into is-a relation(s);
Split/Merge | to split the current entity type into two entity types or merge two entity types linked by a one-to-one relationship type;
Add Tech ID | to add a technical primary id to the current entity type.

Rel-type

-> Entity type | to transform the current rel-type into an entity type;
-> Attribute | to transform the current rel-type into a reference attribute (foreign key);
-> Object att. | to transform the current rel-type into an object type attribute.

Attribute

-> Entity type | to transform the current attribute into an entity type;
Disaggregation | to replace a compound attribute with its components;
Multi -> Single | to transform a multivalued attribute into a single-valued one;
Single -> Multi | to transform a single-valued attribute into a multivalued one;
Multi -> List Single | to transform a multivalued attribute into a list of single-valued ones;
Multi Conversion | to change the collection type of the current attribute (with or without loss);
Materialize domain | to replace the user-defined domain of the current attribute with its definition;
Object att. -> RT | to transform an object type attribute into a rel-type.

Role

Multi-ET -> RT

to transform a multi-ET role into a set of rel-types.

Group

-> Rel-type | to transform a reference group (foreign key) into a rel-type;
Aggregation | to transform the components of a group into a compound attribute;
-> Multi-valued | to transform a group of single-valued attributes into a multivalued attribute.

See also:

Transformation menu


The process modeling toolbox

Process modeling tool palette

 | to update the selected products with the help of primitive functions;
 | to stop using primitives;
 | to create a new engineering process using selected products as input/for update;
 | to terminate the current engineering process using selected products as output;
 | to resume a terminated process;
 | to decide which products must be kept/abandoned.
See also:Engineering menu.


The user toolbox

User tool palettes

Each User tool palette contains shortcuts to maximum 25 Voyager 2 programs or menu commands and corresponds to one of the 10 File/User tools/… menu entries. To configure these tool palettes/menus, see File/Configuration/User-defined menu

See also:

File/User tools menu, File/Configuration/User-defined menu.


The textual data schema window

Textual data schema window (ER and UML Class Diagram)

Four textual views are proposed:

Text compact

To display the names of the following objects:

- | schema,
- | collections,
- | entity types,
- | rel-types.

Text standard

To display a short description of the following objects:

- | schema including its notes and processing units (+ notes),
- | collections including their notes and entity types,
- | entity types including their notes, super-types, attributes (+ notes), processing units (+ notes) and groups (+ notes),
- | rel-types including their notes, roles, attributes (+ notes), processing units (+ notes) and groups (+ notes).

Text extended

To display an extended description of the following objects:

- | schema including its notes and processing units (+ notes),
- | collections including their notes and entity types,
- | entity types including their notes, super-types, sub-types, attributes (+ type, length, number of decimal digits, notes), processing units (+ notes), groups (+ notes) and roles,
- | rel-types including their notes, roles, attributes (+ type, length, number of decimal digits, notes), processing units (+ notes) and groups (+ notes).

Text sorted

To display the names of all objects of the schema (except for groups and notes) sorted in alphabetical order.

The textual schema window is a hypertext representation of the current schema. There are many ways to browse through those views (see mouse and keyboard actions below).

Selected objects remain selected when changing the view mode. If only one object is selected, it is displayed in the center of the window.

Mouse actions

Left button (single click): | to select an object;
Left button (double click): | to open the property box of an object;
Ctrl + left button (single click): | to add an object to the current selection or remove an already selected object from it;
Shift + left button (single click): | to select all objects displayed between the clicked object and a previously selected one;
Right button (single click): | to go to the origin definition of the clicked object, e.g. clicking on a role leads to its entity type.

Keyboard actions

Enter key: | to open the property box of the selected object;
Tab key: | to display the next occurrence of the selected object (marked with >>) in the center of the window;
Up-arrow: | to scroll the schema one line upwards;
Down-arrow: | to scroll the schema one line downwards;
Left-arrow: | to scroll the schema one column to the left;
Right-arrow: | to scroll the schema one column to the right;
Alt + up-arrow: | to swap the selected attribute, processing unit, group or role with the previous one;
Alt + down-arrow: | to swap the selected attribute, processing unit group or role with the next one;
Del key: | to delete the selected object(s).

Note

If only one object is selected, it is the current object. In all other cases, there is no current object. All instances of the current object are marked with “>>”.

See also : View Menu and Graphical data schema window


The graphical data schema window

Graphical data schema window (ER and UML Class Diagram)

Two graphical views are proposed:

Graph. compact

To display a graphical description of the following objects:

- | schema,
- | entity types,
- | rel-types,
- | roles,
- | collections,
- | sub-types,
- | notes.

Graph. standard

To display a graphical description of the following objects:

- | schema including its processing units,
- | entity types including their attributes, processing units, groups and constraints,
- | rel-types including their attributes, processing units, groups and constraints,
- | roles,
- | collections including their entity types,
- | sub-types,
- | notes.

Mouse actions

Left button (single click): | to select an object;
Shift + left button (single click): | to add an object to the current selection or remove an already selected object from it;
Draw a rectangle: | to do a multiple selection;
Drag selected objects: | to move the selected objects;
Left button (double click): | to open the property box of an object;
Right button (single click): | on a rel-type: to align the rel-type with its entity types;
 | on a role: to align the role with its rel-type and its entity type(s);
If the mouse pointer leaves the window while the left-side button is down, the window is automatically scrolled.

Keyboard actions

Enter key: | to open the property box of the selected object (if only one is selected);
Up-arrow: | to move the selected object(s) four pixels upwards; if there is no current selection, the schema is scrolled one line upwards;
Down-arrow: | to move the selected object(s) four pixels downwards; if there is no current selection, the schema is scrolled one line downwards;
Left-arrow: | to move the selected object(s) four pixels to the left; if there is no current selection, the schema is scrolled one column to the left;
Right-arrow: | to move the selected object(s) four pixels to the right; if there is no current selection, the schema is scrolled one column to the right;
Alt + up-arrow: | to swap the selected attribute, processing unit, group or role with the previous one;
Alt + down-arrow: | to swap the selected attribute, processing unit, group or role with the next one;
Ctrl + left-arrow: | to move the selected object(s) one pixel to the left;
Ctrl + right-arrow: | to move the selected object(s) one pixel to the right;
Ctrl + up-arrow: | to move the selected object(s) one pixel upwards;
Ctrl + down-arrow: | to move the selected object(s) one pixel downwards;
Del key: | to delete the selected object(s);

Note

If only one object is selected, it is the current object. In all other cases, there is no current object.

See also : View Menu and Textual data schema window


The textual UML activity diagram window

Textual UML Activity Diagram window

Four textual views are proposed :

Text compact

To display the names of the following objects:

- | schema,
- | action states,
- | object states (internal and external).

Text standard

To display a short description of the following objects:

- | schema including its notes,
- | action states including their notes and relations with other action states (control flows) and object states (object flows) including their own notes,
- | object states including their decomposition and notes.

Text extended

To display an extended description of the following objects:

- | schema including its notes,
- | action states including their notes and relations to other action states (control flows) and with object states (object flow) including their own notes, as well as relations of which they are the target including their notes,
- | object states including their decomposition, notes and object flows.

Text sorted

To display the names of all objects of the schema sorted in alphabetical order.

The textual schema window is a hypertext representation of the current schema. There are many ways to browse through those views (see mouse and keyboard actions below).

Selected objects remain selected when changing the view mode. If only one object is selected, it is displayed in the center of the window.

Mouse actions

Left button (single click): | to select an object;
Left button (double click): | to open the property box of an object;
Ctrl + left button (single click): | to add an object to the current selection or remove an already selected object from it;
Shift + left button (single click): | to select all objects displayed between the clicked object and a previously selected one;
Right button (single click): | to go to the origin definition of the clicked object, e.g. clicking on a control flow relationship in an action state definition leads to the called action state.

Keyboard actions

Enter key: | to open the property box of the selected object;
Tab key: | to display the next occurrence of the selected object (marked with >>) in the center of the window;
Up-arrow: | to scroll the schema one line upwards;
Down-arrow: | to scroll the schema one line downwards;
Left-arrow: | to scroll the schema one column to the left;
Right-arrow: | to scroll the schema one column to the right;
Alt + up-arrow: | to swap the selected internal object with the previous one;
Alt + down-arrow: | to swap the selected internal object with the next one;
Del key: | to delete the selected object(s);

Note

If only one object is selected, it is the current object. In all other cases, there is no current object. All instances of the current object are marked with “>>”.

See also : View Menu, Graphical UML Activity Diagram window


The graphical UML activity diagram window

Graphical UML Activity Diagram window

A standard graphical view is proposed:

Graph. standard

To display a graphical description of the following objects:

- | schema,
- | action states,
- | states of internal and external objects,
- | notes.

Mouse actions

Left button (single click): | to select an object;
Shift + left button (single click): | to add an object to the current selection or remove an already selected object from it;
Draw a rectangle: | to do a multiple selection;
Drag the selected object(s): | to move the selected objects;
Left button (double click): | to open the property box of an object.
If the mouse pointer leaves the window while the left-side button is down, the window is automatically scrolled.

Keyboard actions

Enter key: | to open the property box of the selected object (if only one is selected);
Up-arrow: | to move the selected object(s) four pixels upwards; if there is no current selection, the schema is scrolled one line upwards;
Down-arrow: | to move the selected object(s) four pixels downwards; if there is no current selection, the schema is scrolled one line downwards;
Left-arrow: | to move the selected object(s) four pixels to the left; if there is no current selection, the schema is scrolled one column to the left;
Right-arrow: | to move the selected object(s) four pixels to the right; if there is no current selection, the schema is scrolled one column to the right;
Alt + up-arrow: | to swap the selected internal object with the previous one;
Alt + down-arrow: | to swap the selected internal object with the next one;
Ctrl + left-arrow: | to move the selected object(s) one pixel to the left;
Ctrl + right-arrow: | to move the selected object(s) one pixel to the right;
Ctrl + up-arrow: | to move the selected object(s) one pixel upwards;
Ctrl + down-arrow: | to move the selected object(s) one pixel downwards;
Del key: | to delete the selected object(s).

Note

If only one object is selected, it is the current object. In all other cases, there is no current object.

See also : View Menu, Textual UML Activity Diagram window


The textual UML use case diagram window

Textual UML Use Case Diagram window

Four textual views are proposed:

Text compact

To display the names of the following objects:

- | schema,
- | use cases,
- | actors.

Text standard

To display a short description of the following objects:

- | schema including its notes,
- | use cases including their notes and relations (extend, include, specialization and association with actors + notes).
- | actors including their notes and specializations.

Text extended

To display an extended description of the following objects:

- | schema including its notes,
- | use cases including their notes, relations (extend, include, specialization and association with actors + notes) as well as the relations of which they are the target including their notes,
- | actors including their notes, specializations and generalizations, as well as the use cases to which they are associated.

Text sorted

To display the names of all use cases and actors of the schema sorted in alphabetical order.

The textual schema window is a hypertext representation of the current schema. There are many ways to browse through those views (see mouse and keyboard actions below)

Selected objects remain selected when changing the view mode. If only one object is selected, it is displayed in the center of the window.

Mouse actions

Left button (single click): | to select an object;
Left button (double click): | to open the property box of an object;
Ctrl + left button (single click): | to add an object to the current selection or remove an already selected object from it;
Shift + left button (single click): | to select all objects displayed between the clicked object and a previously selected one;
Right button (single click): | (on relations only) to go to the target object of the clicked relation. For example, clicking on an include relation leads to the included use case, clicking on an included in relation leads to the including use case.

Keyboard actions

Enter key: | to open the property box of the selected object;
Tab key: | to display the next occurrence of the selected object (marked with >>) in the center of the window;
Up-arrow: | to scroll the schema one line upwards;
Down-arrow: | to scroll the schema one line downwards;
Left-arrow: | to scroll the schema one column to the left;
Right-arrow: | to scroll the schema one column to the right;
Del key: | to delete the selected object(s).

Note

If only one object is selected, it is the current object. In all other cases, there is no current object. All instances of the current object are marked with “>>”.

See also : View Menu, Graphical UML Use Case window


The graphical UML use case diagram window

Graphical UML Use Case Diagram window

A standard graphical view is proposed:

Graph. standard

To display a graphical description of the following objects:

- | schema,
- | use cases,
- | actors,
- | notes.

Mouse actions

Left button (single click): | to select an object;
Shift + left button (single click): | to add an object to the current selection or remove an already selected object from it;
Draw a rectangle: | to do a multiple selection;
Drag the selected object(s): | to move the selected objects;
Left button (double click): | to open the property box of an object.
If the mouse pointer leaves the window while the left-side button is down, the window is automatically scrolled.

Keyboard actions

Enter key: | to open the property box of the selected object (if only one is selected);
Up-arrow: | to move the selected object(s) four pixels upwards; if there is no current selection, the schema is scrolled one line upwards;
Down-arrow: | to move the selected object(s) four pixels downwards; if there is no current selection, the schema is scrolled one line downwards;
Left-arrow: | to move the selected object(s) four pixels to the left; if there is no current selection, the schema is scrolled one column to the left;
Right-arrow: | to move the selected object(s) four pixels to the right; if there is no current selection, the schema is scrolled one column to the right;
Ctrl + left-arrow: | to move the selected object(s) one pixel to the left;
Ctrl + right-arrow: | to move the selected object(s) one pixel to the right;
Ctrl + up-arrow: | to move the selected object(s) one pixel upwards;
Ctrl + down-arrow: | to move the selected object(s) one pixel downwards;
Del key: | to delete the selected object(s).

Note

If only one object is selected, it is the current object. In all other cases, there is no current object.

See also : View Menu, Textual UML Use Case Diagram window


The graphical project window

Graphical project window

Three graphical views are proposed:

Graph compact: | To display all products of the current project linked with their derived dependencies. This view is read-only, products and processes cannot be created or deleted, they can only be opened (possibly for modification).
Graph standard: | To display all products of the current engineering process together with the sub-processes that use, transform or generate them.
Graph dependency: | To display all products of the current engineering process with their derived dependencies.

Mouse actions

Left button (single click): | to select an object (schema or text file);
Shift + left button (single click): | to add an object to the current selection or remove an already selected object from it;
Draw a rectangle: | to do a multiple selection;
Drag the selected object(s): | to move the selected objects;
Left button (double click): | to open the window of an object (last used view for a schema, source file window for a text file, history for an engineering process);
Right button (single click): | on a product: to align the product with its processes;
 | on a process: to align the process with its products;
'Close Window' icon | to close the history of the current process and either display the history of its parent (if any) or close the project (otherwise).
If the mouse pointer leaves the window while the left-side button is down, the window is automatically scrolled.

Keyboard actions

Enter key: | to open the window of the selected object (if only one is selected);
Up-arrow: | to move the selected object(s) four pixels upwards; if there is no current selection, the window is scrolled one line upwards;
Down-arrow: | to move the selected object(s) four pixels downwards; if there is no current selection, the window is scrolled one line downwards;
Left-arrow: | to move the selected object(s) four pixels to the left; if there is no current selection, the window is scrolled one half-screen to the left;
Right-arrow: | to move the selected object(s) four pixels to the right; if there is no current selection, the window is scrolled one half-screen to the right;
Ctrl + left-arrow: | to move the selected object(s) one pixel to the left;
Ctrl + right-arrow: | to move the selected object(s) one pixel to the right;
Ctrl + up-arrow: | to move the selected object(s) one pixel upwards;
Ctrl + down-arrow: | to move the selected object(s) one pixel downwards;
Del key: | to delete the selected object(s).
To add a product to this window use Product/New schema or Product/Add text. The drag & drop technique can also be used to add a text file: select a file in the Explorer (for example) and drop it on the project window (standard or dependency).


The source file window

Source file window

The Source file window displays the selected text file. Text files cannot be edited inside DB-MAIN. However, text lines can be marked and colored. A textual description can be associated to any text line.

To mark a line, select it and click on the Mark button or use the Edit/Mark command. Marked lines are displayed in bold type.

To view or modify the description of a line, double click on the line and the description dialog box appears.

Mouse actions

Left button (single click): | to select a line;
Left button (double click): | to edit the description of the selected line;

Ctrl + left button (single click):

to add a line to the current selection or remove an already selected line from it;

Shift + left button (single click):

to select all lines displayed between the clicked line and a previously selected one.

See also : Dependency graph, Program slicing


The method window

Method window

When a project is associated with a method, the Method window displays a graphical representation of the chosen method. The analyst's duty is to follow this method while the latter is intended to guide the analyst through his engineering activities. When creating such a project, the engineering method window is displayed on top. Currently allowed process types are green-colored (colors can be configured through the File/Configuration menu item, section Method), others are grey. To start working, the analyst must choose a process type among the green ones, click on it with the right mouse button and select Execute in the contextual menu. The chosen process type turns red and a process is created in the project window, then:

- | If it is an engineering process type, its strategy becomes the new content of the method window and its history is displayed in the project window. In the method window, its sub-processes that can be executed are green-colored, so that the user can choose what to do next. When an engineering process has been completed, the analyst can select all the products that he considers to be output ones and must terminate the process (Engineering/End current process command). A dialog window appears to confirm the list of output products.
- | If it is an automatic primitive process type, the user may have to answer one or two questions, then the process is performed automatically.
- | If it is a manual primitive process type, the user can open and transform any product using the available tools (in menus and toolbars). When such a manual primitive process has been completed, the user must select it in the history window and terminate it (Engineering/End use of primitives command).
- | If it is a decision, a dialog box appears and the analyst can choose which products to keep and type a comment (rationale of the choice,…)
When a process of a given type has been completed, new processes of the same type can be performed by selecting Execute in the contextual menu of the process type again.
When all the processes of a given type have been performed, the user can select Terminate in the contextual menu of the process type. The completed process type turns black and those that can be performed next turn green. When an engineering process type can be terminated (i.e. when its strategy has been followed up to an end), its title turns red.

Mouse actions

Left button (double click): | on a product or primitive process type: to open the property box of the selected product or primitive process type;
 | on an engineering process type: to display the strategy of the selected engineering process type;
Right button (single click): | to display a contextual menu;
'Close Window' icon | to close the current process type and either display its parent (if any) or close the method window (otherwise).

Process types contextual menus

Execute | to execute a process of the selected type;
Terminate | to terminate the execution of the processes of the given type;
Properties | on a product type or a process type: to show the property box of the selected object;
View | on an engineering process type: to display its strategy instead of the current one;
Back | on the title of the current engineering process type: to close its view and display the parent process type strategy.
See also: Stuctured history