1 RECORD

 The RECORD statement lets you name and define data structures in a BASIC
 program  and  provides the BASIC interface to the Oracle CDD/Repository.
 You can use the defined RECORD name anywhere a BASIC data  type  keyword
 is valid.

 Example

 RECORD Emp_wage_class
        GROUP Emp_name
              STRING First  = 15
              STRING Middle = 1
              STRING Last   = 14
        END GROUP Emp_name
        VARIANT
              CASE
                 GROUP Hourly
                       DECIMAL(4,3) Hourly_wage
                       SINGLE Regular_pay_ytd
                       SINGLE Overtime_pay_ytd
                 END GROUP Hourly
              CASE 
                 GROUP Salaried
                       DECIMAL(7,2) Yearly_salary
                       SINGLE Pay_ytd
                 END GROUP Salaried
        END VARIANT
 END RECORD Emp_wage_class

 Once you specify a record structure, you  declare  a  variable  of  that
 record  type  by  using  the  RECORD  name  as a data type keyword.  For
 instance, using the data structure defined above:

     DECLARE Emp_wage_class Emp_variable

 To reference the fields of the record, specify the record variable  name
 and  the  name of the field being accessed separated by two colons.  You
 can also specify any intermediate GROUP names.  However, they  are  only
 necessary  if  more  than  one field of the record has the same name and
 excluding the GROUP names  would  make  the  reference  ambiguous.   For
 example,  the  following assignment statements reference the same record
 field:

     Emp_variable::pay_ytd = 5000
     Emp_variable::Salaried::pay_ytd = 5000

2 Syntax

  RECORD rec-name
         rec-component
        .
        .
        .
  END RECORD [ rec-name ]

    rec-component:  { data-type rec-item [,...] }
                    { group-clause                              }
                    { variant-clause                            }

    rec-item:       { unsubs-var [ = int-const ]                }
                    { array ( [int-const1 TO] int-const2,...) 
                      [ = int-const]                            }
                    { FILL [ ( int-const ) ] [ = int-const ]    }

    group-clause:   GROUP group-name [ ( int-const,... ) ]
                          rec-component
                              .
                              .
                              .
                    END GROUP [ group-name ]

    variant-clause: VARIANT
                       case-clause
                            .
                            .
                            .
                    END VARIANT

    case-clause:    CASE
                       [ rec-component ]
                             .
                             .
                             .