The GNADE Project Editor Michael Erdmann last update 3. Jan.  2008

Contents

• Project Objectives and Organization
• Current Status
• Implementation Overview
  • Embedded SQL for Ada 95
  • The ODBC Interface
  • Native Bindings
  • Current Documentation (GNADE Release 1.6.X)
  • Object Persistency

• Development Agenda
  • SQL IDE
  • Command Line Tools
  • Ada Database Connectivity (ADBC) Interface
  • Object Databases (object persistence)
  • Ada Object Database Server (ADB)

• Supported Platforms and Databases
• Release Road map
• Project Communication
• License and Download
• Resources
• Project Applications of GNADE
• Other Ada RDBMS Interface Projects
• Download & Release Notes

Project Objectives and Organization

The GNADE (GNat Ada Database Environment) project is an open source project with the primary goal to provide all tools and packages necessary to create an Ada 95 development environment providing a seamless integration of relational databases and other database products with Ada 95.

The project provides the following software packages:

• Thin bindings to different RDBMS products like Oracle, PostgreSQL, MySQL using ODBC.
• Embedded SQL.
• Native bindings to other RDBMS aproaches such as sqlite
• Object persistency (ODB).

The ODBC interface has been selected as primary interface to the underlying data base because most of the known DBCS do provide this interface and it is already well understood and established standard.

The embedded SQL approach has been implemented by several vendors (Informix, Adabas, Oracle eg. PRO*Ada and many more) for Ada and other languages. This aproach allows the reuse of old legacy code.Embedding of SQL in Ada 95 requires either a compiler capable of parsing embedded SQL and Ada at the same time, or (the approach of the GNADE project) a precompiler which expands the SQL code into Ada statements which will be compiled later by the Ada Compiler.

Embedding of SQL in Ada 95 requires either a compiler capable of parsing embedded SQL and Ada at the same time, or (the approach of the GNADE project) a precompiler which expands the SQL code into Ada statements which will be compiled later by the Ada Compiler.

Currently all development is done for the GNU Ada Toolchain (GNAT) but the the support of other compliers is not outside of the project scope. The supported compilers depend on the available maintainers.

The project activities and results are hosted at http://sourceforge.net/projects/gnade.

All technical communication besides of error reporting is done via the mailing list gnade-develop@lists.sourceforge.net

Error reporting should be done by means of the bug reporting facilities at source forge where the project is hosted.

If you like to contribute to the project, please contact Michael Erdmann.

Current Status

The GNADE project provides a complete solution for developing database based applications in Ada 95.This solution allows to use all ODBC complient data base systems.

The components of the GNADE Project, their status and authors are listed in the table below.

Implementation Overview

The result of the GNADE project are packaged in different packages as listed below:

Embedded SQL for Ada 95

The ISO/92 standard for embedded SQL defines for languages as Cobol, C and Ada how the embed SQL commands into the source code. For each language a certain escape keyword is defined which indicates the begin of an SQL statement. Following such a keyword, the SQL statement is inserted. The SQL syntax is basically the same except for the constructs to implement the communication between application and embedded SQL code.

The application communicates with the underlying data base by means of the following mechanisms:

• Host variables
  A host vairable is a varable which contains either an input parameter or the result of a query. ISO/92 defines a small set of data types which are all defined in the package SQL_STANDARD.
  
  
• SQLSTATE, SQLCODE
  Each executed query returns information about the executed query in these two variables which are made available by the ESQL translators. The result is stored in the two variables SQLSTATE and SQLCODE.
  
  
• Conditions
  For each query you may specify an action which will be executed if e.g. the query returns an error. This feature is normally used to handle error conditions.
  
  

A typical Ada 95 code fragment containing embedded SQL is shown below:

Delare_ERROR : exception;
Open_ERROR   : exception;

EXEC SQL DECLARE BEGIN                                  (1)
   empno : SQL_Standard.INTEGER;
   ...
EXEC SQL END-EXEC

EXEC SQL                                                (2)
   WHENEVER SQLERROR raise Declare_Error;        

EXEC SQL                                                (3)
   DECLARE emp_cursor CURSOR FOR 
   SELECT empno, name INTO :empno, :name 
   FROM employees
   WHERE manager = :to_find;

EXEC SQL                                          
   WHENEVER SQLERROR raise Open_ERROR;  
EXEC SQL                                                (4)
    OPEN emp_cursor;

loop                                                    
   EXEC SQL 
      FETCH emp_cursor;                                 (5)

   exit when SQLCODE in SQL_STANDARD.SQL_ERROR;         (6)
     
   Put_Line(.... name );

end loop;
    

In the example above each statement which is not preceded by the string "EXEC SQL" is assumed to be an Ada 95 statement. Every thing preceded by the EXEC ESQL string till the next semicolon is assumed to be a ISO/92 SQL statement.

Statement 1 : This section contains the declaration of the host variables which are used to communicate between application and dbcs. Important to note, that only a view standard types have been defined in the ISO/92 standard for this purpose.

Statement 2 : This embedded statement declares, that an exception SQL_Error has to be raised when the following query returns the SQLERROR condition. Please note, that this clause is only valid until the next embedded SQL statement is executed (in this case Statement 3).

Statement 3 : This statement defines a cursor denoted by "emp_cursor", it does not create any result set.

Statement 4 : This statement initiates the execution of the query by the underlying data base system and some of the tuples will be made available after that statement returns. However, note that the database engine might block at some point generating these tuples. The engine will unblock, once some of the tuples are fetched in by statement 5.

Statement 5 : This statement fetches a new tuple of the result set of the cursor denoted by "emp_cursor". Important to note that the result of this operation is stored in the host variables as they are defined in the INTO clause of the statement (3).

Statement 6 : The result code SQLCODE is checked. If the SQLCODE indicates, that no record has been found, exit the loop.

The ODBC Interface (by J.Pfeifer)

The ODBC interface consists of a so called driver manager and the ODBC driver it self. The driver manager (DM) is a library that on one site offers the specified ODBC API to applications. The DM therefore is what you essentially link to your application. But in large parts the DM routines are only stubs.
At run time the DM decides which database to access and based on the type of the database which vendors database ODBC driver to load. So basically most DM implementations require that the OS supports dynamic linking and that the database vendors provide the database site of the ODBC drivers as dynamic loadable entity (aka DLL or shared libraries). But the DM does more than just to provide these stubs and the dynamic linking of the corresponding implementations. As ODBC evolves over time, the DM is also responsible to handle the situation that with a new version of ODBC new API entries are defined, but they are not available in a database driver because this driver was developed when an earlier version of ODBC was the rule (for example we now have ODBC 3.52 and the MySQL ODBC driver is written for ODBC 2.5x). So an application might link against an ODBC 3.52 DM and use all the new and hot ODBC entries, although the database used doesn't have them in its ODBC driver. The DM usually reacts in one of two ways:

• it raises an error indicating an unsupported call.
• it emulates the new call by translating it to a previous (maybe deprecated) call or series of calls. Funny enough this happens quite often and the way how to emulate a new call by existing ones is in most cases exactly described in the ODBC spec.

The mechanism how to select the right driver is system dependent, but the principal idea is that you have some kind of repository where you associate logical names with configuration information telling the DM the specifics which driver to load. On Win32 this repository can be the registry or so called DSN-files, on UNIX this is mostly an ODBC.INI file containing the information in some structured fashion. The application opens the database by specifying such a logical name and its the task of the DM to consult the repository and to dynamically load the right database driver. In this way, a carefully written application can not only be written in a database independent fashion (using the ODBC API), but also the resulting binary can be dynamically configured to use different databases. This is what makes ODBC so successful on Win32 and will make it more and more important also on UNICes. You can write very generic data aware code ranging from applications like MS Access that can operate on any database that supports ODBC, to GUI widgets like data grids that you can incorporate into your GUI application and that binds "magically" to nearly any database you want.

The database ODBC driver is typically a sharable object that implements the ODBC interface on the database site and is loaded by the DM. In theory - although quite uncommon - you may link such a driver directly to your application. This will work if your application makes only ODBC calls that are implemented by the ODBC version used when writing the database driver. Your application then is written in a database independent fashion, but the binary is bound to a specific database.

Native Bindings

The ODBC provides a standardized way to access a data base which is completely sufficient to implement applications. Any how every DBCS provides services and features which are not supported ODBC, but exactly these additional features may be the the reason why a certain DBCS is selected for usage. For this reason does the GNADE project provide so called native bindings to several DBCS client libraries.
The purpose of these libraries is to provide a interface to the vendor specific features of a data base system. This topic is a low priority issue in Version 1.0. This will change with Version 3.0. This Version will attempt to provide an interface which will allow the use embedded SQL and the native bindings in the same Ada 95 source package.

Currently available are the following bindings:

• MySQL 3.X and 4.X
• PostgreSQL
• SQLite

Object Persistency

Object persistency for Ada 95 is introduced by means of a small language extension. A Ada 95 data type can be declared as persistent using the following construct:

   type Object is persistent record
          First_Name  : attribute String( 1..40 ) := (others =>' ');
          Last_Name   : attribute String( 1..40 ) := (others =>' ');
          Boss        : attribute Persistent.Reference := null;
       end record ; 

Object persistency means, that the object survives the shutdown of the application. In order to achive this, the object has to be wirtten into some kind of persistent storage, from where it is retrieved upon start of the appliation. This requieres, that every object has some kind of unique object identifier. In the current implementation it is a task of the application to define the object identifier.

with MyObject;
with ODB.Persistent;        
with ODB.Storage.File;             
......          
use  ODB;
procedure Main is 
   O          : ODB.Reference ;
   File_Store : File.Object;                            (1)
begin
   File.Load(File_Store);                               (2)

   O := Lookup_Object( "First_Object" );                (3)
   if O = null then     
      O := new Person.Object;                           (4)
      Object_Name( O, "First_Object" );
   
      O.A := 1;
   end if;
   ........... do some thing ......

   File.Save(File_Store);                               (5)
exception
   when Others =>
      ,.......
end Main;
    

In (1) a file object is decalred which is used to access the persistent storage which is in fact loaded in (2). At this point only the object directory is loaded but not the objects them self.

In (3) a lookup for the given object identifier is done. If the lookup return null, the object is not yet existing and it will be created by means of (4) and a name is assigned to the object.

At termination of the application the currently loaded objects are wirtten back into the persistent storage.

The currently implementation provides only user local binary and xml files. A server based aproach is under construction.

For more information please refere to the documentation of ODB.

The directory gnade/contrib/objects contains a technology demonstration which shows how to use an object oriented approach  together with a RDBMS. This is a protoying effort and currently under development. For more details either refere to the CVS and the documentation.

Development Agenda

The table below list the current development Agenda:

Object Oriented Databases

All the previously presented approaches don't take the object oriented features of Ada 95 into account. In the context of this no activity has been planed yet, but an interesting point would be to achieve some kind of object persistence for Ada 95. For further information on this issue you may refere to http://www.cetus-links.org/.

The package ODB provides a small language extension to Ada 95 which provides small scale object persistency.

Supported Platforms and Databases

This section summaries the major software platform and databases known to support the GNADE project.

If you find any additional environment or you have ported the software to a new environment please keep us informed that we can update this list and include your modification into the next major release..

Release Road map

Project Communication

The project internal communication is done via two channels:

The technical discussion is done via a public mailing list which is hosted at sourceforge:

gnade-develop@lists.sourceforge.net

To subscribe or handle your preferences send a message with Help as contents to:

gnade-develop-request@lists.sourceforge.net

or use the web based interface.

The release of new software is automatically announced by the sourceforge site if you register your self to monitor a certain software package on the sourceforge project page (http://sourceforge.net/projects/gnade).

License and Download

The code of the GNADE project has been placed under the GNU Public License (GPL) with the following extension::

The following explaination published at comp.lang.ada may help you to understand the consequences of this so called "GNAT Modified GPL":

There are three methods of getting GNADE:

• The source code of the lates version as tar file from the GNADE project page. After downloading you have to build GNADE your self.

• Prebuild rpm packages for Redhat and SuSe Linux are also available at http://www.gnuada.org/.
• Via read access to the CVS archive at cvs.gnade.sourceforge.net. Change into the directory where you want to install the GNADE development environment and enter the commands below:
  
  cvs -d:pserver:anonymous@cvs.gnade.sourceforge.net:/cvsroot/gnade login
  cvs -z3 -d:pserver:anonymous@cvs.gnade.sourceforge.net:/cvsroot/gnade co gnade
  
  Every time you are prompted for the password of anonymous simply press enter.
  
  For write access you need to be registered with sourceforge as a developer. After registration contact Michael Erdmann to add you as a developer.
  
  While using the CVS you should be be aware of the following strategy. If software is relesed (e.g. the tools package version 0.1.1), it will be branched with the label RELEASE_0_1_1. Corrections to the offically delivered package will be made on the release branch. If a package is created from this, it will get the version 0.1.2 and it will be labled with the label RELEASE_0_1_2 (or 0_1_1a as shown below). In the main line you will find a label indicating the branch point.

The development will continue on the main line and the changes done in the production branch are merged regualry in the main line (trunk) if applicable.

Resources

There are some documents about and arround the GNADE project available:

Projects known to use GNADE

I expect that this list is not complete, since i dont ask for feedback explicitly but at least sometimes i get some information about project applicaitons. These are listed below.

• Very Simple and powerful Picture Server
• Port of Propel to Ada done by  Graham Stark

Other Ada RDBMS interface projects

Below you find a list Ada 95 projects providing Database interfaces to RDBMS products.

• The PostgreSQL/MySQL APQ 2.1 Thick Binding
• PostgreSQL binding by Maciej Sobczak (http://msobczak.com/prog/bin/)
• RDBMS completly implemented in Ada

© 2001-2008 Michael Erdmann

$Revision: 1.34 $ $Date: 2008/01/03 08:23:47 $