Frequently Asked Questions

  • Basics - Does DB-MAIN support ascending and descending legacy ?

    The descending and ascending legacy is not implemented in DB-MAIN.

    Solution : You must achieve the transformation manually or write a Java module that will perform this transformation.

  • Basics - How to add identifiers to association types ?

    To add identifiers to association types via the [New/Group] menu :

    Solution : You must select the attributes and/or roles of the association types which shall participate to the identifier, then click on the [New/Group] menu and select the "Identifier" function in the group's property box (or simply click on the "Identifier" button on the standard toolbar).
    If this menu (or button) is grayed out, the selected objects cannot form an identifier group of the association types.

  • Basics - How to ask the user to enter data during execution of a Java plugin in DB-MAIN ?

    The DBMConsole class allows to capture the output stream, but not to enter data.

    Here's how to remedy this :

    Solution : You can use the following code to display a dialog box to enter data. The use of this box is simple. You give it the title, the question asked, the type of icon that you want to see appear and it returns the answer in a string.
    Example : String response = JOptionPane.showInputDialog(null,
    "What is your name?",
    "Enter your name",

  • Basics - How to create a nonstandard attribute for the generation of database creation scripts ?

    For example, if you want to create TEXT attributes (that is to say attributes that will have the TEXT type in a relational database), you can do it like this :

    Solution : To remedy to this type of problem, we set up a mechanism allowing generators ([File/Generate] menu) to take into account the physical types specific to a language (in our case, type TEXT). This mechanism consists in the updating of the user property "physType" ("User prop." tab from the property box). The value set in this property will be taken into account for the generation (only if it exists, otherwise you take DB-MAIN's own type). This feature is available since version 9.1.1 of DB-MAIN.

  • Basics - How to create a user defined domain (and subdomains) ?

    If you try to add a user defined domain to a project : how can it be decomposed while containing subdomains ?

    Solution : When you create your primary domain using the dialog box ([Product / User domain ...] menu, [New] or [Modify] buttons), you have two buttons [First dom.] and [Next dom.]. The [Next dom.] button creates a user domain of the same level. On the other hand, the [First dom.] button creates a subdomain of the current domain. You can thus create decomposable user domains.

  • Basics - How to create hybrid identifiers ?

    There are commands to create an hybrid identifier (containing attributes and roles).

    Solution : In the LIBRARY schema (ABOUT dialog box, button [Demo project]), to create the hybrid identifier of COPY (of.BOOK, Copy-No), first select role [0-N] played by entity-type BOOK in relationship-type of and attribute Copy-No of COPY. After that, click on ID button in the standard toolbar to create the hybrid identifier.

  • Basics - How to give a multiple cardinality [N,N] to an association type ?

    This possibility does not exist in the choice of the "cardinality" line from the property box. Indeed, DB-MAIN does not accept N-N cardinality for a role as it considers that it is impossible to verify this constraint in a database. This would mean that each instance of a table playing a N-N role should have mandatory countless links with another table.

    Solution : To create an association many-to-many [N-N], just give the 0-N cardinality to both roles.

  • Basics - How to launch a Java plug-in (with or without JRE) in DB-MAIN ?

    If you installed the version of DB-MAIN with integrated JRE, running a Java plug-in should run without intervention.

    If you have not installed the version with the JRE, here's how to proceed :

    Solution : you need to change your PATH environment variable to add the path to the jvm.dll library of the JRE installed on your computer. For example, add the path C:\Program Files\J2sdk1.4.1_03\Jre\Bin\Client in the PATH variable. Restart DB-MAIN for the changed variable to be taken into account.

  • Basics - How to rearrange the attributes of my entities or associations ?

    If you want to move up/down an attribute in an entity type or association type.

    Solution : To reorder your attributes in an entity type or association type, simply select the attribute and press the up arrow key (or down) of the keypad while simultaneously holding down the ALT key. Your attribute will then move up (or down).

  • Basics - How to rename two or more relations with the same name ?

    For example, if you want to rename a relationship type using the same name : province has district - district has village. By you can't write 'has' the second time.

    Solution: In DB-MAIN, the relationship types (like entity types) must have a unique name in a schema. But you can use the pipe ('|') at the end of the names to ensure the unicity. You can rename relations 'has|1' between 'province' and 'district' and 'has|2' between 'district' and 'village'. On the screen, you'll see twice 'has'. The pipe and characters after will not be displayed.

  • Basics - How to represent a weak entity in DB-MAIN ?

    In order to represent an entity whose identifier is related to another entity.

    Solution : It is possible to represent a weak entity type in DB-MAIN.

    For example, run DB-MAIN and, in the About dialog box, click the Library (demo project) button. Open the LIBRARY/Conceptual schema by double-clicking it. In this schema, you see that the identifier of the entity type COPY comprises its Copy-No attribute and the distant role 0-N played by BOOK in association type of. In the case of COPY, we speak of weak entity.

    To create an identifier of a weak entity type, be sure to select the role of the strong entity and not the one played by the weak entity in the relationship between them.

    For your information, a role is the object that has a cardinality, which is the link between two entity types. Generally (in the case of binary association between two entity types), there are two roles (cardinalities) on a link. The cardinality of a role is the minimum and maximum number of times an instance of an entity type can be connected to the instances of the related entity types. In a schema Entity/Association, it may be 1-1, 0-N, 1-N, 4-5 (provided that the minimum cardinality is less than or equal to the maximum cardinality). In an UML class diagram, it will be 1, *, 1-*, 4-5.

  • Basics - How to represent reflexive associations ?

    Here's how you go about creating a reflexive association type in a graphic view :

    Solution : You must first create an association type ([New/Rel type] menu). Click where you want to create it. Press ESC to stop the "graphic design" mode. Then go to the [New/Role/Rel-type/Link] menu to create both roles. Click the association type, hold the button and release it on the entity concerned. Repeat the same operation for the second role. Press ESC to stop the "graphic design" mode. You now have a reflexive association type.

  • Basics - Impossible to create attributes (grayed out in New menu)

    To create an attribute, it is necessary that the object for which you want to create it (entity type, association type or compound attribute) is selected.

    Solution : You must select an entity type, an association type or compound attribute and go to the [New/Attribute/First Att...] menu. If the [Attribute] menu is grayed out, it means that you are not in the correct view to see the created attributes (for example, the compact view). If you select the "View/Graph. standard" menu, you will see all the attributes that you have already created.
    DB-MAIN has multiple views (textual or graphic) that can work on all schema types. The default view of a schema is the standard graphical view.

  • Basics - The characters on some toolbars are too small

    You are using version 5.* or lower under Windows 2000. You should be using version 9 or higher.

  • Basics - The configuration parameters do not work

    When you change the value of a parameter you must click the change button before you close the dialog box or the changes will not be saved.

    Exit and restart DB-MAIN (some parameters are read at startup).

    Examine the contents of db_main.ini file ("Windows" directory in version 8 or lower, "Documents and Settings\xxx\Application Data\DB-Main" directory in version 9 or higher). This file records the current parameters.

  • Basics - The graphical toolbar is invisible

    The toolbar is closed.

    Solution: Access this toolbar through Window/Graphical tools

    The toolbar is open but has been moved beyond the limits of the screen.

    Solution : Increase the resolution of the screen to show the bar or edit the db_main.ini configuration file ("Windows" directory in version 8 and lower, "\Documents and Settings\xxx\Application Data\DB-Main" directory in version 9 and higher). In version 8 and lower, in [TOOL_POS], set GRAPH_X to 0 (GRAPH_X=0) and GRAPH_Y to 0 (GRAPH_Y=0). In version 9 or higher, in [Perspectives], set Layout to nothing (Layout=).

  • Basics - The results of the Copy Graphic function don't appear right

    Some strings may be so long that they stretch out of their box when they are imported into selected documents. DB-MAIN draws the selected objects on the clipboard rather than on screen. Box sizes are calculated to surround the longest string on the screen. When the string is pasted into another medium (a Word document for example), Windows may impose different parameters, so that some strings appear shorter or longer than they do on screen and extend beyond the limits of the box.

    Solution: Select the box in the Word document and stretch it horizontally until it covers all the strings. NB: there is no relation between how the schema looks in a DB-MAIN window (always correct), in a Word document and on paper. We would welcome any elegant workarounds.
    The problem may be encountered with selected reduction factors only. Always identify the reduce factors that give the best results on your installation and use them consistently.

    An uncommon but annoying problem that may affect some graphic cards (e.g. ASUS-MEW V2.1 released in 1999) is that the length of an entity type box is a little smaller than the lines that define the various compartments (Name, Attribute, Group, etc). This may result in unattractive drawings in a Word document for example. This is a graphic card driver problem. Other software exhibits GUI problems too.

    Solutions: You need a more recent card driver. In the Word document, double-click on the schema, then close it.

  • Getting Help - DB-MAIN asks me questions when I open selected projects

    These questions are about projects developed in versions 1 to 3 of DB-MAIN. New concepts have been added to subsequent versions and DB-MAIN is trying to upgrade these projects. Your project will never be corrupted, no matter what answer you give.

    First question: "Convert the parameters in the descriptions into dynamic properties?"

    Explanation: There are two ways to add meta-properties in DB-MAIN (see Tutorials and Reference Manuals): the old-style semi-formal parameters (the "#property=value#" sentences in SEM or TECH annotations) and the more formal dynamic properties (visible in PROP). This question asks whether you want to convert the semi-formal parameters into dynamic properties. It is perfectly safe to answer ‘Yes’. This will preserve some interesting schema properties.

    Second question: "Convert connections into processes?"

    Explanation: In earlier versions, schemas and other products were independent and arrows (connections) between them simply indicated informal dependency relations. In more recent versions the relations between products have been precisely defined by certain processes (a process uses products to build other products). This question asks you whether you want to convert the informal relations into (fictional) processes. It is perfectly safe to answer "Yes".

  • Getting Help - DB-MAIN cannot open an existing project

    DB-MAIN is upward compatible. This means that any project developed in version X can be imported by version Y with Y >=X. DB-MAIN is not downward compatible however, because the repository is extended.

    Solution: Use the correct version. Also try to generate an ISL project (File/Save as in *.ISL or *.XML format), which is more version-insensitive (provided no method was used).

    The project may be corrupted. You can send us your project and we will try to salvage it.

  • Getting Help - How do I use DB-MAIN ?

    IMPORTANT for Windows Vista and Windows 7 users : At first start, run DB-MAIN as administrator (right click on the shortcut DB-MAIN and select Run as administrator) to allow the license file writing. Next starts, run DB-MAIN normally.

    There is a sixty-minute FirstStep tutorial to help you get acquainted with database design and DB-MAIN manipulation. This short tutorial is included in the DB-MAIN release (1st-step.hlp). It can be accessed from the welcome box when you start the tool or run it independently.

    Expand your knowledge with the extended Introduction to Database Design (300 pages). Follow the twelve lessons and work through the exercises.

    For more in-depth learning on database modelling, read the first volume in the Computer-aided Database Engineering (400 pages).

  • Getting Help - How do I use DB-MAIN on Mac ?

    Since april 2015, DB-MAIN is available on Mac OS X.

    Solution: Download the Mac OS X version of DB-MAIN and read carefully the readme.html file before setup.

  • Getting Help - If DB-MAIN denies your license number

    DB-MAIN requests a serial number on startup when the license file does not exist (first run) or when the license is no longer valid.

    If, after the introduction of a serial number, the OK button does not work, it means that the license number is incorrect.

    Solution : Make sure you enter a license number compatible with the version of DB-MAIN. If you try to introduce a license number version 9 with DB-MAIN 8, it will not work. In this case, you must download the new version and use the license number sent automatically. If the license number is compatible with the version, check it has been properly introduced. If the problem persists, please contact us.

    If, after the introduction of your number, the message [Your DB-MAIN license has expired. You can renew it on www.db-main.eu (Download tab).] appears, it means that the validity date of the license number is exceeded.

    Solution : Renew your license number by going to the Download section of the website (select License renewal in the download form).

    If, after the introduction of number, the message [Impossible to generate the DB_MAIN.LIC file. Check that you have write permissions on the DB-MAIN setup directory.] appears, it means that DB-MAIN does not have permissions to write the license file in its setup directory. This problem appears especially on Windows Vista and Windows 7.

    Solution : Run DB-MAIN as administrator (right click on the shortcut DB-MAIN and select Run as administrator). Next starts, run DB-MAIN normally.

  • Getting Help - Installation problem on Centos

    If you try to install DB-Main on Centos 6.0 / i386, in VMWare Fusion 4 (fresh install), you may encounter a problem to launch DB-Main, libtiff is missing.

    db_main: error while loading shared libraries: libtiff.so.4: cannot open shared object file: No such file or directory

    Solution : You can try to locate the libtiff library on Centeos : "locate libtiff.so". If you find another version (e.g. libtiff.so.3), you can make a symbolic link with "sudo ln -s /usr/lib/libtiff.so.3 /usr/lib/libtiff.so.4" and retry DB-MAIN.

  • Getting Help - Missing libraries on Windows

    DB-MAIN requests specific Visual Studio libraries. Some errors can appear such as :

    The program can't start because api-ms-win-crt-stdio-l1-1-0.dll is missing from your computer. Try reinstalling the program to fix this problem.

    Solution : Proceed as follows :

    Install Windows Updates

    • Go to Start - Control Panel - Windows Update
    • Check for updates
    • Install all available updates
    • After the updates are installed, restart your computer
    • After the restart, repeat the steps above again until no more updates are available

    If the problem persists

    • Download the Visual C++ Redistributable :
      • For Windows 64-bit : Visual C++ Redistributable for Visual Studio 2015 (64-bit).
      • For Windows 32-bit : Visual C++ Redistributable for Visual Studio 2015 (32-bit).
    • Run the vcredist_x64.exe (64-bit) or vcredist_x86.exe (32-bit) and select "Uninstall".
    • Run the .exe again and select "Install and restart the computer".
  • Linux - Compatibility problem between Linux and Windows LUN files

    If you use the Linux version of DB-MAIN, you may experience compatibility problems to open a LUN file generated under the Windows version of our software.

    You do have the possibility to use LUN files simultaneously on Linux and Windows.

    Solution :

    • First, be careful that LUN files are binary files. If you transfer these files by FTP, you must choose the binary option.
    • Secondly, verify that Linux and Windows use the same encoding before using DB-MAIN (by default Linux is UTF/8 and Windows CP1252. If it is not the case, you must change the LUN file encoding (some text editors have these functionalities).
  • Linux - Corrupted DB_MAIN.INI under Linux

    You may encounter this issue : under Linux, there's no button available to draw anything (only the Zoom factor button and the Mark button).

    Solution : It seems to be a resource problem with DB-MAIN. You can delete the DB_MAIN.ini file in your /home/username/.db_main directory and try again.

  • Linux - Library error on DB-MAIN launch under Linux

    This is mainly to solve the problems of missing libraries to run the Linux version of DB-MAIN.

    If you receive the following error on the screen :

    ./db_main: error while loading shared libraries: libwx_gtk2_core-x.y.so.0: cannot open shared object file: No such file or directory

    Solution : Make sure that you have updated the environment variable LD_LIBRARY_PATH

    The path to the DB-MAIN bin directory must be there. In the readme.html file, we propose to update the environment variables like this :

    # Edit the .bashrc file (.profile in some environment) in the home directory
    # and add the following lines (adapt the ~/db-main/bin directory to the one chosen previously):
    export DB_MAIN_BIN=~/db-main/bin
    export PATH=$DB_MAIN_BIN:$PATH
    export LD_LIBRARY_PATH=$DB_MAIN_BIN:$DB_MAIN_BIN/../java/jre/lib/i386/client:$LD_LIBRARY_PATH

    If you receive another library error :

    Solution : Make sure that you have not tried to install a 32-bit version of DB-MAIN under a Linux 64-bit (or vice versa). If this is the case, download the correct version in accordance with your operating system.

  • Schemas - DB-MAIN refuses to create new objects

    You are in a view schema; view schemas have limited update capabilities.

    Solution: work in the source schema instead.

    The tool is in History controlled mode and no process working on this schema is active (in other words, the schema is no longer updateable). In this mode, a product whose creation process has been closed cannot be updated or the chain of products would be rendered inconsistent. For instance, adding an attribute to a conceptual schema after its SQL code has been generated and compiled yields an inconsistent project.

    Solution: Uncheck the Engineering/Control box. Be advised that project consistency checking will be lost.

  • Schemas - Distant objects become inactive in large schemas

    The graphical space of DB-MAIN is very large, covering several square kilometres with a resolution of 1 micro-metre. In Windows the window covers only about 64 square metres. A particularly large schema can be obtained by reverse engineering, for example. In this case the entity types are displayed side by side, so that an 8-metre wide graph is relatively common. A graphical object that extends beyond the window may not be exhibited properly.

    Solution: Select a smaller zoom factor to bring the object back within the window. You can then move the distant objects towards the centre of the schema.

  • Schemas - How to make an EPS copy for LaTeX in a graphical view ?

    Want to use your schemas to illustrate a LaTeX report, in EPS or PDF format ?

    Solution : DB-Main has no EPS/PDF output. To use graphical views in a document, you must select the elements of a schema that must be taken into account. Go to "Edit/Copy graphic" menu (or right-click of the mouse). Under Windows, the image is saved in the clipboard. Under Linux, it is saved in a BMP, PNG or JPEG file. To use the result in LaTeX, you'll have to use an image conversion tool to EPS/PDF format.

  • Schemas - Management of large schemas

    Large projects are always difficult to manage. Large amounts of entity types are difficult to integrate into the main schema.

    Solution : We recommend that you develop each subsystem separately in a schema of the same DB-MAIN project.
    When the subsystems are completed, we propose to integrate them (by copy/paste) in an integrated schema. This will allow you to create connections between subsystems. For your convenience, you can view your schemas in textual views (View/Text... menu). When working on large schemas, we use these views that were created for this purpose. These are hyperlinks that offer a range of interesting navigation functions. We recommend you to consult the Help section for more information.

  • Schemas - Screen refreshing is slowed down in large schemas

    DB-MAIN uses an intelligent algorithm to refresh the graphical representation of schemas. Only those objects that intersect with the visible window are redrawn. This is one of the reasons why DB-MAIN is so fast. Drawing the arcs is a more complex process. An arc linking two invisible objects may traverse the screen, in which case it is visible, and must be redrawn. Identifying the arcs that traverse the screen is a time-consuming process, so we have decided to redraw all the arcs in the schema. A schema that includes 40,000 arcs – like some call graphs in very large applications – will clearly take more time to refresh. The problem is rarely critical for data schemas. If you experience a problem like this the graph will probably be displayed as a solid black screen and it will be unreadable. This is a limitation of graphical representation: it works well with small graphs but is not suited to large graphs.

    Solution: Use the hypertext representation instead. It is fast, readable and easier to use.

  • Schemas - The LUN file size increases abnormally

    If you find that, despite the few changes made to a project, the LUN file size increases abnormally. Maybe, willingly or not, you have activated the recording of all operations performed on a schema. This creates a log file (operation history) which is automatically saved in your LUN file.

    Solution: For all schemas, check that tracing is disabled (menu Log/Trace) and, if necessary, clear the log already registered (menu Log/Clear log). Before deleting the log, you can also save it in a different file (menu Log/Save log as...) in order to be replayed later (menu Log/Replay). To achieve the file cleaning, save your project.

  • Schemas - Unique values for an attribute in an ER schema

    How to show that an attribute must contain unique values in an ER schema ?

    Solution : To show that an attribute must contain unique values in an ER schema, you must create an identifier containing this attribute.
    To create an identifier, select one or more attributes in a same entity type and click on the ID button in the standard toolbar.

  • Specifics - How do I model a postGIS database with geometric types in DB-MAIN ?

    DB-MAIN is a generic data modelization tool. It is not specialized for specific databases like geographical databases. In this context, for example, longitude and latitude are not standard attribute types in DB-MAIN.
    But you can define your own specific types in user-defined properties.

    Solution : For example, select an attribute. In the property box panel (menu Windows/Property box if not shown), click on "User prop." tab.
    On the line "physType", you can give your own type (e.g. Latitude).
    You can also give a value like "latitude(%l)" where %l represents the attribute length defined in the "Prop" tab (%d for number of decimals).

    The SQL generators take into account the "physType" property if not empty. You can also develop your own postGIS generator (java plugin) by using the Java Interface for DB-MAIN (See the file "SQLGenerator.java" in "plugins/sql" directory of your DB-MAIN setup directory).

  • Specifics - How to create an Access database from DB-MAIN ?

    What is the procedure to create an Access database from a DB-MAIN MPD ?

    Solution :

    • In DB-MAIN, generate Access code on a relational schema (File/Generate/Access menu...).
    • Take the Access database (SQL-Interpreter.mdb) supplied with DB-MAIN (for example in your directory C:\Program Files\DB-Main x.y.z\plugins\access\).
    • Run the "Execute SQL script" form.
    • Select the Access script generated by DB-MAIN ("Find script") and run the script ("Execute script").
    • The Access database contains the MPD defined in DB-MAIN.
  • Specifics - How to get an MCD from a relational MLD/MPD ?

    Here's how to get an MCD from the relational MLD/MPD :

    Solution :

    • Open the MLD/MPD schema.
    • Make a copy of the schema (Product/Copy product... menu).
    • Open the copied schema.
    • Transform the schema into an MCD. To do this :
      • Run the Assist/Global transformation... menu.
      • Click the Predefined button.
      • Select the Relational rev. eng. input and click the Ok button.
      • Run the transformations. Click the Ok button.
  • Specifics - How to obtain an MPD/MLD from a relational database ?

    Here are briefly described the three ways to recover the structure of a SQL database in DB-MAIN :

    Solution :

    1. Extraction of the DDL (SQL script) :
      Prerequisite : to have a file containing the SQL statements for the construction of a database (CREATE TABLE, CREATE INDEX, ALTER TABLE, ...).
      Instructions :
      • Start DB-MAIN and create a new project (File/New project... menu).
      • Run the SQL extractor (File/Extract/SQL... menu).
      • Select the file to extract.
      • A new schema is created. Double-click on it and you'll see all the structures recovered by DB-MAIN.

      Note : It may be that some statements are not recognized. Our extractor being generic (independent from technologies such as : DB2, Oracle, SQL Server, ...), there may be some statements not taken into account (especially the technical parameters such as information storage). This is normally not a problem because they have no impact on the logical model of the database. Putting these statements in comment, it is possible to bypass the extraction problems.

    2. ODBC extraction :
      Prerequisite : to have on your machine the ODBC drivers allowing you access to the affected database types and to have set an ODBC data source.
      Instructions :
      • Start DB-MAIN and create a new project (File/New project... menu).
      • Run the ODBC extractor (File/Extract/ODBC... menu).
      • Select the "Machine Data Source" tab. In the list, select a pre-defined source (Access, for example) or a source that you yourself created.
      • Select your database. A dialog box asks you for a schema name. Fill the field if necessary (unnecessary with Access for example) and click OK..
      • A new schema is created. Double-click on it and you'll see all the structures recovered by DB-MAIN.

      Note : It may be that some recovered system tables are not necessary. Just select them and delete them.

    3. JDBC extraction :
      Prerequisite : to have on your machine the Java JDBC drivers allowing you access to the affected database types and configure the environment variable CLASSPATH.
      Instructions :
      • Start DB-MAIN and create a new project (File/New project... menu).
      • Create a new schema (Product/New schema... menu).
      • Run the JDBC extractor (File/Execute plug-in... menu). Open the file "JDBCExtraction.class" in the directory "plugins\jdbc" of the installation directory of DB-MAIN.
      • Select a DBMS (other, if you do not find your database type). Set the driver if necessary. Give the connection URL. Enter the username and password if necessary.
      • A new schema is created. Double-click it and you'll see the structures recovered by DB-MAIN.

      Note : It may be that some recovered system tables are not necessary. Just select them and delete them.

    Note : The JDBC extraction, when applicable, is the best solution to get a full MPD of your database.

  • Specifics - How to recover a MPD Access in DB-MAIN ?

    If you want to recover through reverse engineering a MPD from a database established in Access with DB-Main.

    Solution : To recover a MPD Access in DB-MAIN, here's how :

    • Start DB-MAIN and create a new project (File/New project menu...).
    • Run the ODBC extractor (File/Extract/ODBC menu...).
    • Select the "Machine Data Source" tab. In the list, select "MS Access Database" and click OK.
    • Select your Access database. A dialog box asks for a schema name (which has no interest in the context of Access). Leave the field blank and click OK.
    • A new schema is created. Double-click it and you will see all the information retrieved by DB-MAIN.

    It may be that some recovered system tables are not necessary (as MSysAccess ...). Just select them and delete them.

  • Specifics - SQL code generation problem when creating your relational database

    When you try to generate the SQL script of your MCD via the [File/Generate] menu but the generated SQL script does not meet your needs (syntax problem, lack of information), what solution do you have ?

    Solution : We recommend you to use the Java plugins to create your own generator. To do this, you have a good base with the SQLGenerator.java program in the plugins/sql directory from the DB-MAIN installation. You can use and transform this program to meet your needs.