1  Preprocessors
   Oracle Rdb preprocessors check and process Oracle Rdb statements in
   your program, converting the Oracle Rdb statements to host language
   calls to the database. RDBPRE, the preprocessor for BASIC, COBOL,
   and FORTRAN, automatically invokes the necessary host language
   compiler for your program. You must invoke the host language
   compiler after you preprocess a C or Pascal program with the RDML
   preprocessor.


2  Callable_RDO

   Callable RDO is a program interface that you must use when Oracle Rdb
   does not support a preprocessor for your program language.  You can also
   use this interface when you want to perform Rdb data definition tasks or
   dynamic data manipulation tasks in BASIC, C, COBOL, FORTRAN, or Pascal
   programs.

   When you use the Callable RDO program interface, your program
   communictes with Oracle Rdb using a callable function, RDB$INTERPRET.
   Unlike preprocessor interfaces, the Callable RDO interface performs in
   an interpretive manner.

   The Rdb statements you use in your pgoram are string literals.  When the
   program executes, the statements are passed to Oracle Rdb in the calls
   to RDB$INTERPRET.  The interactive Rdb interface, RDO, then interprets
   and executes them.

   You call the RDB$INTERPRET function as you would call a VMS Run-Time
   Library routine.  In the calling sequence, you pass both Rdb statements
   and host language variables that cuase values from teh database to be
   retrieved or updated.  The call to RDB$INTERPRET returns a status value
   that indicates the success or failure of the statements.  If the call
   was successful, RDB$INTERPRET also returns retrieved database values to
   the appropriate program variables.

   For more information, refer to the Guide to Using RDO, RDBPRE, and
   RDML.

3  Restriction

   If the program that uses Callable RDO (RDB$INTERPRET) is linked
   implicitly with SYS$SHARE:RDBINTSHR (that is, allows the OpenVMS Linker
   utility (LINKER) to resolve the reference using
   SYS$LIBRARY:IMAGELIB.OLB) then the message vector and transaction handle
   values are not returned to the caller.

   However, if the program is linked explicitly with SYS$SHARE:RDBINTSHR
   as the following example shows, then message vector and transaction
   handle values are returned.  In this case, there must be two PSECTs
   declared and named RDB$TRANSACTION_HANDLE (8 bytes long) and
   RDB$MESSAGE_VECTOR (20 longwords, that is, 80 bytes long) in the
   caller's program.

   $ LINK PROGRAM,SYS$INPUT/OPT
   SYS$SHARE:RDBINTSHR.EXE/SHARE
   PSECT_ATTR=RDB$MESSAGE_VECTOR,SHR
   PSECT_ATTR=RDB$TRANSACTION_HANDLE,SHR

   However the explicit linking against the shareable image
   SYS$SHARE:RDBINTSHR is not upward compatible and the application will
   need to be relinked for each new version of Oracle Rdb released.

   There is no workaround for this problem.
 

2  RDBPRE
   You can define a symbol to invoke RDBPRE. Once you are in the
   RDBPRE environment, you can specify the programming language and
   the input file specification. For example:

   $ RDBPRE :== $RDBPRE
   $ RDBPRE
   INPUT FILE> MYPROG.RFO/FORTRAN

   A more convenient method is to define a symbol that invokes a
   particular preprocessor. For example, if you frequently use
   the preprocessor with FORTRAN data manipulation language (DML)
   programs:

   $ RFOR :== $RDBPRE/FORTRAN
   $ RFOR MYPROGRAM.RFO
 

3  /BASIC
   Specifies that the input file is a BASIC source file. Following
   successful RDBPRE preprocessing, the resulting file is submitted
   automatically to the BASIC compiler.
 

3  /COBOL
   Specifies that the input file is a COBOL source file. Following
   successful RDBPRE preprocessing, the resulting file is submitted
   automatically to the COBOL compiler.
 

3  /FORTRAN
   Specifies that the input file is a FORTRAN source file. Following
   successful RDBPRE preprocessing, the resulting file is submitted
   automatically to the FORTRAN compiler.
 

3  /INITIALIZE_HANDLES
   The /[NO]INITIALIZE_HANDLES qualifier allow you to control
   whether RDBPRE will initialize RDBPRE-supplied database,
   transaction, and request handles. Use of the /NOINITIALIZE_
   HANDLES qualifier allows you to link a main image against a
   shareable image and share handles between the two.

          Format:
                 /INITIALIZE_HANDLES     (Default)
                 /NOINITIALIZE_HANDLES

   These qualifiers have no effect on whether or when handles are
   cleared in the generated code; they only control initialization
   of handles in declarations. Furthermore, they only affect
   database, transaction and request handles that RDBPRE declares.
   User-specified transaction and request handles will not be
   initialized when you use the /INITIALIZE_HANDLES qualifier.

   In RDBPRE when you use the /NOINITIALIZE_HANDLES qualifier,
   any handle you specify in your application program must also
   be specified in the shareable image.
 

2  RDML
   You can define a symbol to invoke the Relational Data
   Manipulation Language (RDML) preprocessor. For example:

   $ RDML :== $RDML
   $ RDML
   _Source file: SAL_HISTORY.RC

   A more convenient method is to define symbols. For example:

   $ RDMLC    :== $RDML/C
   $ RDMLPAS  :== $RDML/PASCAL
   $!
   $ RDMLC SAL_HISTORY.RC

   See the RDML Help module that is available from DCL level for
   details.