Quelle  dml112.cob

       IDENTIFICATION DIVISION.
       PROGRAM-ID.  DML112.
       ENVIRONMENT DIVISION.
       CONFIGURATION SECTION.
       SOURCE-COMPUTER.  xyz.
       OBJECT-COMPUTER.  xyz.
       DATA DIVISION.
       WORKING-STORAGE SECTION.


      * EMBEDDED COBOL (file "DML112.PCO")


      ****************************************************************
      *                                                              
      *                 COMMENT SECTION                              
      *                                                              
      * DATE 1993/11/10 EMBEDDED COBOL LANGUAGE                          
      * NIST SQL VALIDATION TEST SUITE V6.0                          
      *  DISCLAIMER:                                                  
      *  This program was written by employees of NIST to test SQL    
      *  implementations for conformance to the SQL standards.        
      *  NIST assumes no responsibility for any party's use of        
      *  this program.
      *                                                              
      * DML112.PCO                                                    
      * WRITTEN BY:  David W. Flater                                 
      * TRANSLATED AUTOMATICALLY FROM EMBEDDED C BY CHRIS SCHANZLE
      *                                                              
      * This routine tests NULLs with DATETIME data types and in     
      * outer joins, datetimes in a <default clause>, TRIM, and also 
      * some schema manipulation statements.                         
      * This is the non-dynamic version of DML113.PC.                
      *                                                              
      * REFERENCES                                                   
      *   FIPS PUB 127-2 14.1 Transitional SQL                       
      *   ANSI SQL-1992                                              
      *                                                              
      ****************************************************************



           EXEC SQL BEGIN DECLARE SECTION END-EXEC
       01  SQLCODE PIC S9(9) COMP.
       01  SQLSTATE PIC  X(5).
       01  uid PIC  X(18).
       01  uidx PIC  X(18).
       01  int1 PIC S9(9) DISPLAY SIGN LEADING SEPARATE.
       01  int2 PIC S9(9) DISPLAY SIGN LEADING SEPARATE.
       01  indic1 PIC S9(4) DISPLAY SIGN LEADING SEPARATE.
       01  chx PIC  X(1).
       01  ch3 PIC  X(2).
       01  ch9 PIC  X(9).
       01  ch10 PIC  X(10).
       01  chtime PIC  X(8).
       01  ch1 PIC  X(11).
       01  ch2 PIC  X(14).
             EXEC SQL END DECLARE SECTION END-EXEC
       01  norm1 PIC S9(9) DISPLAY SIGN LEADING SEPARATE.
       01  norm2 PIC S9(9) DISPLAY SIGN LEADING SEPARATE.
       01  ALPNUM-TABLE VALUE IS
               "01234ABCDEFGH56789IJKLMNOPQRSTUVWXYZ".
           05  ALPNUM PIC X OCCURS 36 TIMES.
       01  NORMSQ.
           05  NORMSQX PIC X OCCURS 5 TIMES.
       01  errcnt PIC S9(9) DISPLAY SIGN LEADING SEPARATE.
      *date_time declaration 
       01  TO-DAY PIC 9(6).
       01  THE-TIME PIC 9(8).
       01  flag PIC S9(9) DISPLAY SIGN LEADING SEPARATE.

       01  SQL-COD PIC S9(9) DISPLAY SIGN LEADING SEPARATE.

       PROCEDURE DIVISION.
       P0.

             MOVE "FLATER            " TO uid
             CALL "AUTHID" USING uid
             MOVE "not logged in, not" TO uidx
             EXEC SQL SELECT USER INTO :uidx FROM HU.ECCO END-EXEC
             MOVE SQLCODE TO SQL-COD
             EXEC SQL ROLLBACK WORK END-EXEC
             MOVE SQLCODE TO SQL-COD
             if (uid  NOT  =   uidx) then
               DISPLAY "ERROR: User ", uid " expected.  User ", uidx "
      -    " connected"
            STOP RUN
             END-IF
             MOVE 0 TO errcnt

             DISPLAY
           "SQL Test Suite, V6.0, Embedded COBOL, dml112.pco"
             DISPLAY
           "59-byte ID"
             DISPLAY "TEd Version #"
      *date_time print 
           ACCEPT TO-DAY FROM DATE
           ACCEPT THE-TIME FROM TIME
           DISPLAY "Date run YYMMDD: " TO-DAY " at hhmmssff: " THE-TIME

      ******************** BEGIN TEST0621 *******************
             MOVE 1 TO flag

             DISPLAY "                  TEST0621 "
             DISPLAY "            DATETIME NULLs (static)"
             DISPLAY "References:"
             DISPLAY "    FIPS PUB 127-2 14.1 Transitional SQL features
      -    " 5,20"
             DISPLAY "   - - - - - - - - - - - - - - - - - - -"

             COMPUTE SQLCODE = -1
             MOVE "xxxxx" TO SQLSTATE

             DISPLAY "CREATE TABLE MERCH ("
             DISPLAY "  ITEMKEY INT,"
             DISPLAY "  ORDERED DATE,"
             DISPLAY "  RDATE DATE,"
             DISPLAY "  RTIME TIME,"
             DISPLAY "  SOLD TIMESTAMP);"

             EXEC SQL CREATE TABLE MERCH (
               ITEMKEY INT,
               ORDERED DATE,
               RDATE DATE,
               RTIME TIME,
               SOLD TIMESTAMP) END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

             DISPLAY "COMMIT WORK;"
             EXEC SQL COMMIT WORK END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

             DISPLAY "CREATE TABLE TURNAROUND ("
             DISPLAY "  ITEMKEY INT,"
             DISPLAY "  MWAIT INTERVAL MONTH,"
             DISPLAY "  DWAIT INTERVAL DAY TO HOUR);"

             EXEC SQL CREATE TABLE TURNAROUND (
               ITEMKEY INT,
               MWAIT DATE,
               DWAIT DATE) END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

             DISPLAY "COMMIT WORK;"
             EXEC SQL COMMIT WORK END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

      *Do this with an outer join in a combined test later. 
      *For FSQL, use SELECT DISTINCT (all that stuff)       

             DISPLAY "CREATE VIEW INVENTORY AS"
             DISPLAY "  SELECT MERCH.ITEMKEY AS ITEMKEY, ORDERED,"
             DISPLAY "  MWAIT, DWAIT FROM MERCH, TURNAROUND COR1 WHERE
      -    " RDATE"
             DISPLAY "  IS NOT NULL AND SOLD IS NULL AND"
             DISPLAY "  MERCH.ITEMKEY = COR1.ITEMKEY"
             DISPLAY "         UNION"
             DISPLAY "  SELECT ITEMKEY, ORDERED,"
             DISPLAY "  CAST (NULL AS INTERVAL MONTH),"
             DISPLAY "  CAST (NULL AS INTERVAL DAY TO HOUR) FROM"
             DISPLAY "  MERCH WHERE RDATE IS NOT NULL AND SOLD IS NULL"
             DISPLAY "  AND MERCH.ITEMKEY NOT IN (SELECT ITEMKEY"
             DISPLAY "  FROM TURNAROUND);"

             EXEC SQL CREATE VIEW INVENTORY AS
               SELECT MERCH.ITEMKEY AS ITEMKEY, ORDERED,
               MWAIT, DWAIT FROM MERCH, TURNAROUND COR1 WHERE RDATE
               IS NOT NULL AND SOLD IS NULL AND
               MERCH.ITEMKEY = COR1.ITEMKEY
               UNION
               SELECT ITEMKEY, ORDERED,
               CAST (NULL2 AS DATE),
               CAST (NULL2 AS DATE) FROM
               MERCH WHERE RDATE IS NOT NULL AND SOLD IS NULL
               AND MERCH.ITEMKEY NOT IN (SELECT ITEMKEY
               FROM TURNAROUND) END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

             DISPLAY "COMMIT WORK;"
             EXEC SQL COMMIT WORK END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

      *Something ordered but not received 

             DISPLAY "INSERT INTO MERCH VALUES ("
             DISPLAY "  0, DATE '1993-11-23',"
             DISPLAY "  NULL, NULL, NULL);"

             EXEC SQL INSERT INTO MERCH VALUES (
               0, '1993-11-23',
               NULL, NULL, NULL) END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

      *Something we don't know what time it arrived 

             MOVE "12:34:56" TO chtime
             DISPLAY "chtime is 12:34:56"
             COMPUTE indic1 = -1
             DISPLAY "indic1 = -1;"
             DISPLAY "INSERT INTO MERCH VALUES ("
             DISPLAY "  1, DATE '1993-12-10',"
             DISPLAY "  DATE '1994-01-03',"
             DISPLAY "  CAST (:chtime:indic1 AS TIME), NULL);"

             EXEC SQL INSERT INTO MERCH VALUES (
               1, '1993-12-10',
               '1994-01-03',
               CAST (:chtime:indic1 AS TIME), NULL) END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

      *Something back-ordered 

             DISPLAY "INSERT INTO MERCH VALUES ("
             DISPLAY "  2, DATE '1993-12-11',"
             DISPLAY "  NULL, NULL,"
             DISPLAY "  CAST ('TIMESTAMP ''1993-12-11 13:00:00''' AS
      -    " TIMESTAMP));"

             EXEC SQL INSERT INTO MERCH VALUES (
               2, '1993-12-11',
               NULL, NULL,
               CAST ('TIMESTAMP ''1993-12-11 13:00:00''' AS TIMESTAMP))
             END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

             DISPLAY "INSERT INTO MERCH VALUES ("
             DISPLAY "  4, DATE '1993-01-26', DATE '1993-01-27',"
             DISPLAY "  NULL, NULL);"

             EXEC SQL INSERT INTO MERCH VALUES (
               4, '1993-01-26', '1993-01-27',
               NULL, NULL) END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

             DISPLAY "INSERT INTO TURNAROUND VALUES ("
             DISPLAY "  2, INTERVAL '1' MONTH, INTERVAL '20:0' DAY TO
      -    " HOUR);"

             EXEC SQL INSERT INTO TURNAROUND VALUES (
               2, '1' MONTH, '20:0' DAY)
             END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

      *We have only a vague idea of the turnaround for this thing 

             DISPLAY "chtime is 20:0"
             MOVE "20:0    " TO chtime
             DISPLAY "indic1 = -1;"
             COMPUTE indic1 = -1

             DISPLAY "INSERT INTO TURNAROUND VALUES ("
             DISPLAY "  5, INTERVAL '5' MONTH,"
             DISPLAY "  CAST (:chtime:indic1 AS INTERVAL DAY TO HOUR));"

             EXEC SQL INSERT INTO TURNAROUND VALUES (
               5, '5' MONTH,
               CAST (:chtime:indic1 AS DATE)) END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

             DISPLAY "INSERT INTO TURNAROUND VALUES ("
             DISPLAY "  6, INTERVAL '2' MONTH, NULL);"

             EXEC SQL INSERT INTO TURNAROUND VALUES (
               6, INTERVAL '2' MONTH, NULL) END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

             DISPLAY "SELECT COUNT(*) INTO :int1 FROM"
             DISPLAY "  MERCH A, MERCH B WHERE A.SOLD = B.SOLD;"

             COMPUTE int1 = -1
             EXEC SQL SELECT COUNT(*) INTO :int1 FROM
               MERCH A, MERCH B WHERE A.SOLD = B.SOLD END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY "int1 should be 1; its value is ", int1
             if (int1  NOT =  1) then
               MOVE 0 TO flag
             END-IF

             DISPLAY "SELECT COUNT(*) INTO :int1 FROM"
             DISPLAY "  MERCH A, MERCH B WHERE A.RTIME = B.RTIME;"

             COMPUTE int1 = -1
             EXEC SQL SELECT COUNT(*) INTO :int1 FROM
               MERCH A, MERCH B WHERE A.RTIME = B.RTIME END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY "int1 should be 0; its value is ", int1
             if (int1  NOT =  0) then
               MOVE 0 TO flag
             END-IF

             DISPLAY "SELECT COUNT(*) INTO :int1 FROM"
             DISPLAY "  MERCH WHERE RDATE IS NULL;"

             COMPUTE int1 = -1
             EXEC SQL SELECT COUNT(*) INTO :int1 FROM
               MERCH WHERE RDATE IS NULL END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY "int1 should be 2; its value is ", int1
             if (int1  NOT =  2) then
               MOVE 0 TO flag
             END-IF

             DISPLAY "SELECT COUNT(*) INTO :int1 FROM"
             DISPLAY "  TURNAROUND WHERE DWAIT IS NOT NULL;"

             COMPUTE int1 = -1
             EXEC SQL SELECT COUNT(*) INTO :int1 FROM
               TURNAROUND WHERE DWAIT IS NOT NULL END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY "int1 should be 1; its value is ", int1
             if (int1  NOT =  1) then
               MOVE 0 TO flag
             END-IF

             DISPLAY "SELECT EXTRACT (DAY FROM RDATE) INTO :int1:indic1"
             DISPLAY "  FROM MERCH, TURNAROUND WHERE MERCH.ITEMKEY ="
             DISPLAY "  TURNAROUND.ITEMKEY;"

             COMPUTE int1 = -1
             MOVE 2 TO indic1
             EXEC SQL SELECT RDATE INTO :int1:indic1
               FROM MERCH, TURNAROUND WHERE MERCH.ITEMKEY =
               TURNAROUND.ITEMKEY END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY "indic1 should be -1; its value is ", indic1
             if (indic1  NOT =  -1) then
               MOVE 0 TO flag
             END-IF

             DISPLAY "DECLARE C11211 CURSOR FOR"
             DISPLAY "  SELECT ITEMKEY FROM MERCH WHERE SOLD IS NOT
      -    " NULL;"

             EXEC SQL DECLARE C11211 CURSOR FOR
               SELECT ITEMKEY FROM MERCH WHERE SOLD IS NOT NULL END-EXEC

             DISPLAY  " "

             DISPLAY "OPEN C11211;"
             EXEC SQL OPEN C11211 END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

             COMPUTE int1 = -1
             DISPLAY "FETCH C11211 INTO :int1;"
             EXEC SQL FETCH C11211 INTO :int1 END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY "int1 should be 2; its value is ", int1
             if (int1  NOT =  2) then
               MOVE 0 TO flag
             END-IF

      *Cursor left open. 

             DISPLAY "DECLARE C11212 CURSOR FOR"
             DISPLAY "  SELECT EXTRACT (HOUR FROM AVG (DWAIT))"
             DISPLAY "   FROM MERCH, TURNAROUND WHERE"
             DISPLAY "   MERCH.ITEMKEY = TURNAROUND.ITEMKEY OR"
             DISPLAY "   TURNAROUND.ITEMKEY NOT IN"
             DISPLAY "     (SELECT ITEMKEY FROM MERCH);"

             EXEC SQL DECLARE C11212 CURSOR FOR
               SELECT AVG (DWAIT)
               FROM MERCH, TURNAROUND WHERE
               MERCH.ITEMKEY = TURNAROUND.ITEMKEY OR
               TURNAROUND.ITEMKEY NOT IN
               (SELECT ITEMKEY FROM MERCH) END-EXEC

             DISPLAY  " "

             DISPLAY "OPEN C11212;"
             EXEC SQL OPEN C11212 END-EXEC
             MOVE SQLCODE TO SQL-COD

             DISPLAY "SQLCODE should be >= 0; its value is ", SQL-COD
             if (SQLCODE  <  0) then
               MOVE 0 TO flag
             END-IF
             DISPLAY "SQLSTATE can be 00000 or 01003; its value is ",
             SQLSTATE
           PERFORM NOSUBCLASS THRU EXIT-NOSUBCLASS
             if (NORMSQ  NOT  =   "00000"  AND  SQLSTATE  NOT  =  
             "01003") then
               MOVE 0 TO flag
             END-IF

      *DML083 set the precedent for requiring 01003 on the fetches. 
      *One might argue that it ought to be returned just on the     
      *open and never again.  DML083 is under dispute, so status    
      *codes are checked loosely here.                              

             COMPUTE int1 = -1
             DISPLAY "FETCH C11212 INTO :int1;"
             EXEC SQL FETCH C11212 INTO :int1 END-EXEC
             MOVE SQLCODE TO SQL-COD

             DISPLAY "SQLCODE should be >= 0; its value is ", SQL-COD
             if (SQLCODE  <  0) then
               MOVE 0 TO flag
             END-IF
             DISPLAY "SQLSTATE can be 00000 or 01003; its value is ",
             SQLSTATE
           PERFORM NOSUBCLASS THRU EXIT-NOSUBCLASS
             if (NORMSQ  NOT  =   "00000"  AND  SQLSTATE  NOT  =  
             "01003") then
               MOVE 0 TO flag
             END-IF
             DISPLAY "int1 should be 0; its value is ", int1
             if (int1  NOT =  0) then
               MOVE 0 TO flag
             END-IF

             DISPLAY "SELECT COUNT(*) INTO :int1"
             DISPLAY "  FROM INVENTORY WHERE MWAIT IS NULL"
             DISPLAY "  AND DWAIT IS NULL;"

             COMPUTE int1 = -1
             EXEC SQL SELECT COUNT(*) INTO :int1
               FROM INVENTORY WHERE MWAIT IS NULL
               AND DWAIT IS NULL END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY "int1 should be 2; its value is ", int1
             if (int1  NOT =  2) then
               MOVE 0 TO flag
             END-IF

             DISPLAY "COMMIT WORK;"
             EXEC SQL COMMIT WORK END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

             DISPLAY "DROP TABLE MERCH CASCADE;"
             EXEC SQL DROP TABLE MERCH CASCADE END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

             DISPLAY "COMMIT WORK;"
             EXEC SQL COMMIT WORK END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

             DISPLAY "DROP TABLE TURNAROUND CASCADE;"
             EXEC SQL DROP TABLE TURNAROUND CASCADE END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

             DISPLAY "COMMIT WORK;"
             EXEC SQL COMMIT WORK END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

             if ( flag  =  1 ) then
               DISPLAY "                *** pass *** "
               EXEC SQL INSERT INTO HU.TESTREPORT
                 VALUES('0621','pass','PCO') END-EXEC
               MOVE SQLCODE TO SQL-COD
             else
               DISPLAY "       dml112.pco  *** fail *** "
               EXEC SQL INSERT INTO HU.TESTREPORT
                 VALUES('0621','fail','PCO') END-EXEC
               MOVE SQLCODE TO SQL-COD
               COMPUTE errcnt = errcnt + 1
             END-IF

             DISPLAY "==============================================="

             EXEC SQL COMMIT WORK END-EXEC
             MOVE SQLCODE TO SQL-COD
      ******************** END TEST0621 ********************
      ******************** BEGIN TEST0623 *******************
             MOVE 1 TO flag

             DISPLAY "                  TEST0623 "
             DISPLAY "OUTER JOINs with NULLs and empty tables (static)"
             DISPLAY "References:"
             DISPLAY "    FIPS PUB 127-2 14.1 Transitional SQL feature
      -    " 4"
             DISPLAY "   - - - - - - - - - - - - - - - - - - -"

             COMPUTE SQLCODE = -1
             MOVE "xxxxx" TO SQLSTATE

             DISPLAY "CREATE TABLE JNULL1 (C1 INT, C2 INT);"
             EXEC SQL CREATE TABLE JNULL1 (C1 INT, C2 INT)
             END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

             DISPLAY "COMMIT WORK;"
             EXEC SQL COMMIT WORK END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

             DISPLAY "CREATE TABLE JNULL2 (D1 INT, D2 INT);"
             EXEC SQL CREATE TABLE JNULL2 (D1 INT, D2 INT)
             END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

             DISPLAY "COMMIT WORK;"
             EXEC SQL COMMIT WORK END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

             DISPLAY "CREATE VIEW JNULL3 AS"
             DISPLAY "  SELECT C1, D1, D2 FROM JNULL1 LEFT OUTER JOIN
      -    " JNULL2"
             DISPLAY "  ON C2 = D2;"

             EXEC SQL CREATE VIEW JNULL3 AS
               SELECT C1, D1, D2 FROM JNULL1 OUTER JOIN JNULL2
               END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

             DISPLAY "COMMIT WORK;"
             EXEC SQL COMMIT WORK END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

             DISPLAY "CREATE VIEW JNULL4 AS"
             DISPLAY "  SELECT D1, D2 AS C2 FROM JNULL2;"

             EXEC SQL CREATE VIEW JNULL4 AS
               SELECT D1, D2 AS C2 FROM JNULL2 END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

             DISPLAY "COMMIT WORK;"
             EXEC SQL COMMIT WORK END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

             DISPLAY "CREATE VIEW JNULL5 AS"
             DISPLAY "  SELECT C1, D1, C2 FROM JNULL1 RIGHT OUTER JOIN
      -    " JNULL4"
             DISPLAY "  USING (C2);"

             EXEC SQL CREATE VIEW JNULL5 AS
               SELECT C1, D1, C2 FROM JNULL1 OUTER JOIN JNULL4
               END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

             DISPLAY "COMMIT WORK;"
             EXEC SQL COMMIT WORK END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

             DISPLAY "CREATE VIEW JNULL6 AS"
             DISPLAY "  SELECT * FROM JNULL1 LEFT OUTER JOIN JNULL4"
             DISPLAY "  USING (C2);"

             EXEC SQL CREATE VIEW JNULL6 AS
               SELECT * FROM JNULL1 OUTER JOIN JNULL4
               END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

             DISPLAY "COMMIT WORK;"
             EXEC SQL COMMIT WORK END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

             DISPLAY "INSERT INTO JNULL1 VALUES (NULL, NULL);"
             EXEC SQL INSERT INTO JNULL1 VALUES (NULL, NULL) END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

             DISPLAY "INSERT INTO JNULL1 VALUES (1, NULL);"
             EXEC SQL INSERT INTO JNULL1 VALUES (1, NULL) END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

             DISPLAY "INSERT INTO JNULL1 VALUES (NULL, 1);"
             EXEC SQL INSERT INTO JNULL1 VALUES (NULL, 1) END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

             DISPLAY "INSERT INTO JNULL1 VALUES (1, 1);"
             EXEC SQL INSERT INTO JNULL1 VALUES (1, 1) END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

             DISPLAY "INSERT INTO JNULL1 VALUES (2, 2);"
             EXEC SQL INSERT INTO JNULL1 VALUES (2, 2) END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

             COMPUTE int1 = -1
             DISPLAY "SELECT COUNT(*) INTO :int1 FROM JNULL3;"
             EXEC SQL SELECT COUNT(*) INTO :int1 FROM JNULL3 END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY "int1 should be 5; its value is ", int1
             if (int1  NOT =  5) then
               MOVE 0 TO flag
             END-IF

             COMPUTE int1 = -1
             DISPLAY "SELECT COUNT(*) INTO :int1 FROM JNULL3"
             DISPLAY "  WHERE D2 IS NOT NULL OR D1 IS NOT NULL;"
             EXEC SQL SELECT COUNT(*) INTO :int1 FROM JNULL3
               WHERE D2 IS NOT NULL OR D1 IS NOT NULL END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY "int1 should be 0; its value is ", int1
             if (int1  NOT =  0) then
               MOVE 0 TO flag
             END-IF

             DISPLAY "SELECT COUNT(*) INTO :int1 FROM JNULL5;"

             COMPUTE int1 = -1
             EXEC SQL SELECT COUNT(*) INTO :int1 FROM JNULL5 END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY "int1 should be 0; its value is ", int1
             if (int1  NOT =  0) then
               MOVE 0 TO flag
             END-IF

             DISPLAY "SELECT COUNT(*) INTO :int1 FROM"
             DISPLAY "  JNULL6"
             DISPLAY "   WHERE C2 IS NOT NULL;"

             EXEC SQL SELECT COUNT(*) INTO :int1 FROM
               JNULL6
               WHERE C2 IS NOT NULL END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY "int1 should be 3; its value is ", int1
             if (int1  NOT =  3) then
               MOVE 0 TO flag
             END-IF

      *Nonempty table 

             DISPLAY "INSERT INTO JNULL2"
             DISPLAY "  SELECT * FROM JNULL1;"

             EXEC SQL INSERT INTO JNULL2
               SELECT * FROM JNULL1 END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

             DISPLAY "UPDATE JNULL2"
             DISPLAY "  SET D2 = 1 WHERE D2 = 2;"

             EXEC SQL UPDATE JNULL2
               SET D2 = 1 WHERE D2 = 2 END-EXEC
             MOVE SQLCODE TO SQL-COD

             COMPUTE int1 = -1
             DISPLAY "SELECT COUNT(*) INTO :int1 FROM JNULL3;"
             EXEC SQL SELECT COUNT(*) INTO :int1 FROM JNULL3 END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY "int1 should be 9; its value is ", int1
             if (int1  NOT =  9) then
               MOVE 0 TO flag
             END-IF

             COMPUTE int1 = -1
             DISPLAY "SELECT COUNT(*) INTO :int1"
             DISPLAY "  FROM JNULL3 WHERE C1 IS NULL;"

             EXEC SQL SELECT COUNT(*) INTO :int1
               FROM JNULL3 WHERE C1 IS NULL END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY "int1 should be 4; its value is ", int1
             if (int1  NOT =  4) then
               MOVE 0 TO flag
             END-IF

             DISPLAY "SELECT COUNT(*) INTO :int1"
             DISPLAY "  FROM JNULL3 WHERE D1 IS NULL;"

             COMPUTE int1 = -1
             EXEC SQL SELECT COUNT(*) INTO :int1
               FROM JNULL3 WHERE D1 IS NULL END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY "int1 should be 5; its value is ", int1
             if (int1  NOT =  5) then
               MOVE 0 TO flag
             END-IF

             DISPLAY "SELECT COUNT(*) INTO :int1"
             DISPLAY "  FROM JNULL3 WHERE D2 IS NULL;"

             COMPUTE int1 = -1
             EXEC SQL SELECT COUNT(*) INTO :int1
               FROM JNULL3 WHERE D2 IS NULL END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY "int1 should be 3; its value is ", int1
             if (int1  NOT =  3) then
               MOVE 0 TO flag
             END-IF

             DISPLAY "SELECT AVG(D1) * 10 INTO :int1"
             DISPLAY "  FROM JNULL3;"

             COMPUTE int1 = -1
             EXEC SQL SELECT AVG(D1) * 10 INTO :int1
               FROM JNULL3 END-EXEC
             MOVE SQLCODE TO SQL-COD

             DISPLAY "SQLCODE should be >= 0; its value is ", SQL-COD
             if (SQLCODE  <  0) then
               MOVE 0 TO flag
             END-IF
             DISPLAY "SQLSTATE should be 01003; its value is ", SQLSTATE
             if (SQLSTATE  NOT  =   "01003") then
               MOVE 0 TO flag
             END-IF
             DISPLAY "int1 should be 15; its value is ", int1
             if (int1  NOT =  15) then
               MOVE 0 TO flag
             END-IF

             DISPLAY "SELECT COUNT(*) INTO :int1"
             DISPLAY "  FROM JNULL6"
             DISPLAY "   WHERE C2 = 1;"

             COMPUTE int1 = -1
             EXEC SQL SELECT COUNT(*) INTO :int1
               FROM JNULL6
               WHERE C2 = 1 END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY "int1 should be 6; its value is ", int1
             if (int1  NOT =  6) then
               MOVE 0 TO flag
             END-IF

             DISPLAY "SELECT COUNT(*) INTO :int1"
             DISPLAY "  FROM JNULL6"
             DISPLAY "   WHERE C2 IS NULL;"

             COMPUTE int1 = -1
             EXEC SQL SELECT COUNT(*) INTO :int1
               FROM JNULL6
               WHERE C2 IS NULL END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY "int1 should be 2; its value is ", int1
             if (int1  NOT =  2) then
               MOVE 0 TO flag
             END-IF

             DISPLAY "SELECT COUNT(*) INTO :int1"
             DISPLAY "  FROM JNULL6"
             DISPLAY "   WHERE C2 = C1 AND"
             DISPLAY "  D1 IS NULL;"

             COMPUTE int1 = -1
             EXEC SQL SELECT COUNT(*) INTO :int1
               FROM JNULL6
               WHERE C2 = C1 AND
               D1 IS NULL END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY "int1 should be 2; its value is ", int1
             if (int1  NOT =  2) then
               MOVE 0 TO flag
             END-IF

             DISPLAY "COMMIT WORK;"
             EXEC SQL COMMIT WORK END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

             DISPLAY "DROP TABLE JNULL1 CASCADE;"
             EXEC SQL DROP TABLE JNULL1 CASCADE END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

             DISPLAY "COMMIT WORK;"
             EXEC SQL COMMIT WORK END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

             DISPLAY "DROP TABLE JNULL2 CASCADE;"
             EXEC SQL DROP TABLE JNULL2 CASCADE END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

             DISPLAY "COMMIT WORK;"
             EXEC SQL COMMIT WORK END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

             if ( flag  =  1 ) then
               DISPLAY "                *** pass *** "
               EXEC SQL INSERT INTO HU.TESTREPORT
                 VALUES('0623','pass','PCO') END-EXEC
               MOVE SQLCODE TO SQL-COD
             else
               DISPLAY "       dml112.pco  *** fail *** "
               EXEC SQL INSERT INTO HU.TESTREPORT
                 VALUES('0623','fail','PCO') END-EXEC
               MOVE SQLCODE TO SQL-COD
               COMPUTE errcnt = errcnt + 1
             END-IF

             DISPLAY "==============================================="

             EXEC SQL COMMIT WORK END-EXEC
             MOVE SQLCODE TO SQL-COD
      ******************** END TEST0623 ********************
      ******************** BEGIN TEST0625 *******************
             MOVE 1 TO flag

             DISPLAY "                  TEST0625 "
             DISPLAY "       ADD COLUMN and DROP COLUMN (static)"
             DISPLAY "References:"
             DISPLAY "    FIPS PUB 127-2 14.1 Transitional SQL feature
      -    " 3"
             DISPLAY "    11.11 <add column definition>"
             DISPLAY "    11.15 <drop column definition>"
             DISPLAY "   - - - - - - - - - - - - - - - - - - -"

             COMPUTE SQLCODE = -1
             MOVE "xxxxx" TO SQLSTATE

             DISPLAY "CREATE TABLE CHANGG"
             DISPLAY "  (NAAM CHAR (14) NOT NULL PRIMARY KEY, AGE INT);"
             EXEC SQL CREATE TABLE CHANGG
               (NAAM CHAR (14) NOT NULL PRIMARY KEY, AGE2 INT) END-EXEC
             MOVE SQLCODE TO SQL-COD
           PERFORM CHCKOK
             DISPLAY  " "

             DISPLAY "COMMIT WORK;"
             EXEC SQL COMMIT WORK END-EXEC
             MOVE SQLCODE TO SQL-COD
           PERFORM CHCKOK
             DISPLAY  " "

             DISPLAY "CREATE VIEW CHANGGVIEW AS"
             DISPLAY "  SELECT * FROM CHANGG;"
             EXEC SQL CREATE VIEW CHANGGVIEW AS
               SELECT * FROM CHANGG END-EXEC
             MOVE SQLCODE TO SQL-COD
           PERFORM CHCKOK
             DISPLAY  " "

             DISPLAY "COMMIT WORK;"
             EXEC SQL COMMIT WORK END-EXEC
             MOVE SQLCODE TO SQL-COD
           PERFORM CHCKOK
             DISPLAY  " "

      *should not be able to drop CHANGG.NAAM RESTRICT due to 11.15 SR
             DISPLAY "ALTER TABLE CHANGG"
             DISPLAY "  DROP NAAM RESTRICT;"
             EXEC SQL ALTER TABLE CHANGG
               DROP CONSTRAINT NAAM END-EXEC
             MOVE SQLCODE TO SQL-COD
             DISPLAY "SQLCODE should be < 0; its value is ", SQL-COD
             if (SQLCODE  NOT <  0) then
               MOVE 0 TO flag
             END-IF
             DISPLAY "SQLSTATE should be 42000; its value is ", SQLSTATE
           PERFORM NOSUBCLASS THRU EXIT-NOSUBCLASS
             if (NORMSQ  NOT  =   "42000") then
               MOVE 0 TO flag
             END-IF
             if (NORMSQ   =   "42000"  AND  NORMSQ  NOT  =   SQLSTATE)
             then
               DISPLAY "Valid implementation-defined SQLSTATE accepted."
             END-IF

             DISPLAY "COMMIT WORK;"
             EXEC SQL COMMIT WORK END-EXEC
             MOVE SQLCODE TO SQL-COD
             DISPLAY  " "

             DISPLAY "INSERT INTO CHANGG VALUES ('RALPH', 
      -      "22);"
             EXEC SQL INSERT INTO CHANGG VALUES ('RALPH', 
             22) END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

             DISPLAY "INSERT INTO CHANGG VALUES ('RUDOLPH', 
      -      "54);"
             EXEC SQL INSERT INTO CHANGG VALUES ('RUDOLPH', 
             54) END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

             DISPLAY "INSERT INTO CHANGG VALUES ('QUEEG', 
      -      "33);"
             EXEC SQL INSERT INTO CHANGG VALUES ('QUEEG', 
             33) END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

             DISPLAY "INSERT INTO CHANGG VALUES ('BESSIE', 
      -      "106);"
             EXEC SQL INSERT INTO CHANGG VALUES ('BESSIE', 
             106) END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

      *This select should fail 

             DISPLAY "SELECT COUNT(*) INTO :int1"
             DISPLAY "  FROM CHANGG WHERE DIVORCES IS NULL;"
             EXEC SQL SELECT COUNT(*) INTO :int1
               FROM CHANGG WHERE DIVORCES IS NULL END-EXEC
             MOVE SQLCODE TO SQL-COD
             DISPLAY "SQLCODE should be < 0; its value is ", SQL-COD
             DISPLAY "SQLSTATE should be '42000'; its value is '",
             SQLSTATE "'"
             if (SQLCODE  NOT <  0) then
               MOVE 0 TO flag
             END-IF
           PERFORM NOSUBCLASS THRU EXIT-NOSUBCLASS
             if (NORMSQ  NOT  =   "42000") then
               MOVE 0 TO flag
             END-IF
             if (NORMSQ   =   "42000"  AND  NORMSQ  NOT  =   SQLSTATE)
             then
               DISPLAY "Valid implementation-defined SQLSTATE accepted."
             END-IF

             DISPLAY "COMMIT WORK;"
             EXEC SQL COMMIT WORK END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

             DISPLAY "ALTER TABLE CHANGG ADD NUMBRR CHAR(11);"
             EXEC SQL ALTER TABLE CHANGG ADD NUMBRR CHAR(11)
             END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

             DISPLAY "COMMIT WORK;"
             EXEC SQL COMMIT WORK END-EXEC
             MOVE SQLCODE TO SQL-COD
           PERFORM CHCKOK
             DISPLAY  " "

             COMPUTE int1 = -1
             DISPLAY "SELECT MAX(AGE) INTO :int1 FROM CHANGGVIEW;"
             EXEC SQL SELECT MAX(AGE2) INTO :int1 FROM CHANGGVIEW
             END-EXEC
             MOVE SQLCODE TO SQL-COD
           PERFORM CHCKOK
             DISPLAY "int1 should be 106; its value is ", int1
             if (int1  NOT =  106) then
               MOVE 0 TO flag
             END-IF

      *11.11 GR.2:  This statement should fail. 

             DISPLAY "SELECT NUMBRR INTO :ch1 FROM CHANGGVIEW;"
             EXEC SQL SELECT NUMBRR INTO :ch1 FROM CHANGGVIEW END-EXEC
             MOVE SQLCODE TO SQL-COD
             DISPLAY "SQLCODE should be < 0; its value is ", SQL-COD
             DISPLAY "SQLSTATE should be '42000'; its value is '",
             SQLSTATE "'"
             if (SQLCODE  NOT <  0) then
               MOVE 0 TO flag
             END-IF
           PERFORM NOSUBCLASS THRU EXIT-NOSUBCLASS
             if (NORMSQ  NOT  =   "42000") then
               MOVE 0 TO flag
             END-IF
             if (NORMSQ   =   "42000"  AND  NORMSQ  NOT  =   SQLSTATE)
             then
               DISPLAY "Valid implementation-defined SQLSTATE accepted."
             END-IF

             DISPLAY "COMMIT WORK;"
             EXEC SQL COMMIT WORK END-EXEC
             MOVE SQLCODE TO SQL-COD
           PERFORM CHCKOK
             DISPLAY  " "

             DISPLAY "DROP VIEW CHANGGVIEW CASCADE;"
             EXEC SQL DROP VIEW CHANGGVIEW CASCADE END-EXEC
             MOVE SQLCODE TO SQL-COD
           PERFORM CHCKOK
             DISPLAY  " "

             DISPLAY "COMMIT WORK;"
             EXEC SQL COMMIT WORK END-EXEC
             MOVE SQLCODE TO SQL-COD
           PERFORM CHCKOK
             DISPLAY  " "

      *Optional keyword! 

             DISPLAY "ALTER TABLE CHANGG"
             DISPLAY "  ADD COLUMN DIVORCES INT DEFAULT 0;"
             EXEC SQL ALTER TABLE CHANGG
               ADD COLUMN DIVORCES INT DEFAULT 0 END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

             DISPLAY "COMMIT WORK;"
             EXEC SQL COMMIT WORK END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

      *Check that defaults are correct 

             DISPLAY "SELECT COUNT(*) INTO :int1"
             DISPLAY "  FROM CHANGG WHERE NUMBRR IS NOT NULL"
             DISPLAY "  OR DIVORCES <> 0;"
             COMPUTE int1 = -1
             EXEC SQL SELECT COUNT(*) INTO :int1
               FROM CHANGG WHERE NUMBRR IS NOT NULL
               OR DIVORCES <> 0 END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY "int1 should be 0; its value is ", int1
             if (int1  NOT =  0) then
               MOVE 0 TO flag
             END-IF

      *Do some uncomplicated things 

             DISPLAY "UPDATE CHANGG"
             DISPLAY "  SET NUMBRR = '837-47-1847', DIVORCES = 3"
             DISPLAY "  WHERE NAAM = 'RUDOLPH';"
             EXEC SQL UPDATE CHANGG
               SET NUMBRR = '837-47-1847', DIVORCES = 3
               WHERE NAAM = 'RUDOLPH' END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

             DISPLAY "UPDATE CHANGG"
             DISPLAY "  SET NUMBRR = '738-47-1847', DIVORCES = NULL"
             DISPLAY "  WHERE NAAM = 'QUEEG';"
             EXEC SQL UPDATE CHANGG
               SET NUMBRR = '738-47-1847', DIVORCES = NULL
               WHERE NAAM = 'QUEEG' END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

             DISPLAY "DELETE FROM CHANGG"
             DISPLAY "  WHERE NUMBRR IS NULL;"
             EXEC SQL DELETE FROM CHANGG
               WHERE NUMBRR IS NULL END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

             DISPLAY "INSERT INTO CHANGG (NAAM, AGE, NUMBRR)"
             DISPLAY "  VALUES ('GOOBER', 16, '000-10-0001');"
             EXEC SQL INSERT INTO CHANGG (NAAM, AGE, NUMBRR)
               VALUES ('GOOBER', 16, '000-10-0001') END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

             DISPLAY "INSERT INTO CHANGG"
             DISPLAY "  VALUES ('OLIVIA', 20, '111-11-1111', 0);"
             EXEC SQL INSERT INTO CHANGG
               VALUES ('OLIVIA', 20, '111-11-1111', 0) END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

             COMPUTE int1 = -1
             COMPUTE int2 = -1
             MOVE "xxxxxxxxxxx" TO ch1
             DISPLAY "SELECT AGE, NUMBRR, DIVORCES"
             DISPLAY "  INTO :int1, :ch1, :int2"
             DISPLAY "  FROM CHANGG"
             DISPLAY "  WHERE NAAM = 'RUDOLPH';"
             EXEC SQL SELECT AGE, NUMBRR, DIVORCES
               INTO :int1, :ch1, :int2
               FROM CHANGG
               WHERE NAAM = 'RUDOLPH' END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY "int1 should be 54; its value is ", int1
             DISPLAY "int2 should be 3; its value is ", int2
             DISPLAY "ch1 should be '837-47-1847'; its value is '", 
             ch1 "'"
             if (int1  NOT =  54  OR  int2  NOT =  3) then
               MOVE 0 TO flag
             END-IF
             if (ch1  NOT  =   "837-47-1847") then
               MOVE 0 TO flag
             END-IF

             COMPUTE int1 = -1
             COMPUTE int2 = -1
             MOVE 10 TO indic1
             MOVE "xxxxxxxxxxx" TO ch1
             DISPLAY "SELECT AGE, NUMBRR, DIVORCES"
             DISPLAY "  INTO :int1, :ch1, :int2:indic1"
             DISPLAY "  FROM CHANGG"
             DISPLAY "  WHERE NAAM = 'QUEEG';"
             EXEC SQL SELECT AGE, NUMBRR, DIVORCES
               INTO :int1, :ch1, :int2:indic1
               FROM CHANGG
               WHERE NAAM = 'QUEEG' END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY "int1 should be 33; its value is ", int1
             DISPLAY "indic1 should be -1; its value is ", indic1
             DISPLAY "ch1 should be '738-47-1847'; its value is '", 
             ch1 "'"
             if (int1  NOT =  33  OR  indic1  NOT =  -1) then
               MOVE 0 TO flag
             END-IF
             if (ch1  NOT  =   "738-47-1847") then
               MOVE 0 TO flag
             END-IF

             COMPUTE int1 = -1
             COMPUTE int2 = -1
             MOVE "xxxxxxxxxxx" TO ch1
             DISPLAY "SELECT AGE, NUMBRR, DIVORCES"
             DISPLAY "  INTO :int1, :ch1, :int2"
             DISPLAY "  FROM CHANGG"
             DISPLAY "  WHERE NAAM = 'GOOBER';"
             EXEC SQL SELECT AGE, NUMBRR, DIVORCES
               INTO :int1, :ch1, :int2
               FROM CHANGG
               WHERE NAAM = 'GOOBER' END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY "int1 should be 16; its value is ", int1
             DISPLAY "int2 should be 0; its value is ", int2
             DISPLAY "ch1 should be '000-10-0001'; its value is '", 
             ch1 "'"
             if (int1  NOT =  16  OR  int2  NOT =  0) then
               MOVE 0 TO flag
             END-IF
             if (ch1  NOT  =   "000-10-0001") then
               MOVE 0 TO flag
             END-IF

             COMPUTE int1 = -1
             COMPUTE int2 = -1
             MOVE "xxxxxxxxxxx" TO ch1
             DISPLAY "SELECT AGE, NUMBRR, DIVORCES"
             DISPLAY "  INTO :int1, :ch1, :int2"
             DISPLAY "  FROM CHANGG"
             DISPLAY "  WHERE NAAM = 'OLIVIA';"
             EXEC SQL SELECT AGE, NUMBRR, DIVORCES
               INTO :int1, :ch1, :int2
               FROM CHANGG
               WHERE NAAM = 'OLIVIA' END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY "int1 should be 20; its value is ", int1
             DISPLAY "int2 should be 0; its value is ", int2
             DISPLAY "ch1 should be '111-11-1111'; its value is '", 
             ch1 "'"
             if (int1  NOT =  20  OR  int2  NOT =  0) then
               MOVE 0 TO flag
             END-IF
             if (ch1  NOT  =   "111-11-1111") then
               MOVE 0 TO flag
             END-IF

             COMPUTE int1 = -1
             DISPLAY "SELECT COUNT(*) INTO :int1 FROM CHANGG;"
             EXEC SQL SELECT COUNT(*) INTO :int1 FROM CHANGG END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY "int1 should be 4; its value is ", int1
             if (int1  NOT =  4) then
               MOVE 0 TO flag
             END-IF

             DISPLAY "COMMIT WORK;"
             EXEC SQL COMMIT WORK END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

      *Age is nobody's business! 

             DISPLAY "ALTER TABLE CHANGG DROP AGE CASCADE;"
             EXEC SQL ALTER TABLE CHANGG DROP CONSTRAINT AGE 
             END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

             DISPLAY "COMMIT WORK;"
             EXEC SQL COMMIT WORK END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

      *Optional keyword! 

             DISPLAY "ALTER TABLE CHANGG DROP COLUMN DIVORCES RESTRICT;"
             EXEC SQL ALTER TABLE CHANGG DROP CONSTRAINT DIVORCES
             END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

             DISPLAY "COMMIT WORK;"
             EXEC SQL COMMIT WORK END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

      *This select should fail 

             DISPLAY "SELECT COUNT(*) INTO :int1"
             DISPLAY "  FROM CHANGG WHERE AGE > 30;"
             EXEC SQL SELECT COUNT(*) INTO :int1
               FROM CHANGG WHERE AGE > 30 END-EXEC
             MOVE SQLCODE TO SQL-COD
             DISPLAY "SQLCODE should be < 0; its value is ", SQL-COD
             DISPLAY "SQLSTATE should be '42000'; its value is '",
             SQLSTATE "'"
             if (SQLCODE  NOT <  0) then
               MOVE 0 TO flag
             END-IF
           PERFORM NOSUBCLASS THRU EXIT-NOSUBCLASS
             if (NORMSQ  NOT  =   "42000") then
               MOVE 0 TO flag
             END-IF
             if (NORMSQ   =   "42000"  AND  NORMSQ  NOT  =   SQLSTATE)
             then
               DISPLAY "Valid implementation-defined SQLSTATE accepted."
             END-IF

      *This select should fail too 

             MOVE "xxxxx" TO SQLSTATE
             DISPLAY "SELECT COUNT(*) INTO :int1"
             DISPLAY "  FROM CHANGG WHERE DIVORCES IS NULL;"
             EXEC SQL SELECT COUNT(*) INTO :int1
               FROM CHANGG WHERE DIVORCES IS NULL END-EXEC
             MOVE SQLCODE TO SQL-COD
             DISPLAY "SQLCODE should be < 0; its value is ", SQL-COD
             DISPLAY "SQLSTATE should be '42000'; its value is '",
             SQLSTATE "'"
             if (SQLCODE  NOT <  0) then
               MOVE 0 TO flag
             END-IF
           PERFORM NOSUBCLASS THRU EXIT-NOSUBCLASS
             if (NORMSQ  NOT  =   "42000") then
               MOVE 0 TO flag
             END-IF
             if (NORMSQ   =   "42000"  AND  NORMSQ  NOT  =   SQLSTATE)
             then
               DISPLAY "Valid implementation-defined SQLSTATE accepted."
             END-IF

             MOVE "xxxxxxxxxxxxxx" TO ch2
             DISPLAY "SELECT NAAM INTO :ch2"
             DISPLAY "  FROM CHANGG"
             DISPLAY "  WHERE NUMBRR LIKE '%000%';"
             EXEC SQL SELECT NAAM INTO :ch2
               FROM CHANGG
               WHERE NUMBRR LIKE '%000%' END-EXEC
             MOVE SQLCODE TO SQL-COD
           PERFORM CHCKOK
             DISPLAY "ch2 should be 'GOOBER        '; its value is '",
             ch2 "'"
             if (ch2  NOT  =   "GOOBER        ") then
               MOVE 0 TO flag
             END-IF

             DISPLAY "COMMIT WORK;"
             EXEC SQL COMMIT WORK END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

      *create a referential constraint on table CHANGG 

             DISPLAY "CREATE TABLE REFERENCE_CHANGG ("
             DISPLAY "    NAAM CHAR (14) NOT NULL PRIMARY KEY"
             DISPLAY "    REFERENCES CHANGG);"
             EXEC SQL CREATE TABLE REFERENCE_CHANGG (
               NAAM CHAR (14) NOT NULL PRIMARY KEY
               ) END-EXEC
             MOVE SQLCODE TO SQL-COD
           PERFORM CHCKOK
             DISPLAY  " "

             DISPLAY "COMMIT WORK;"
             EXEC SQL COMMIT WORK END-EXEC
             MOVE SQLCODE TO SQL-COD
           PERFORM CHCKOK
             DISPLAY  " "

      *verify referential constraint 
             DISPLAY "INSERT INTO REFERENCE_CHANGG VALUES 
      -       "('NO SUCH NAAM');"
             EXEC SQL INSERT INTO REFERENCE_CHANGG VALUES 
             ('NO SUCH NAAM') END-EXEC
             MOVE SQLCODE TO SQL-COD

             DISPLAY "SQLCODE should be < 0; its value is ", SQL-COD
             if (SQLCODE  NOT <  0) then
               MOVE 0 TO flag
             END-IF
             DISPLAY "SQLSTATE should be 23000; its value is ", SQLSTATE
           PERFORM NOSUBCLASS THRU EXIT-NOSUBCLASS
             if (NORMSQ  NOT  =   "23000") then
               MOVE 0 TO flag
             END-IF
             if (NORMSQ   =   "23000"  AND  NORMSQ  NOT  =   SQLSTATE)
             then
               DISPLAY "Valid implementation-defined SQLSTATE accepted."
             END-IF

             DISPLAY "COMMIT WORK;"
             EXEC SQL COMMIT WORK END-EXEC
             MOVE SQLCODE TO SQL-COD

      *should not be able to drop CHANGG.NAAM RESTRICT due to RI const
             DISPLAY "ALTER TABLE CHANGG"
             DISPLAY "  DROP NAAM RESTRICT;"
             EXEC SQL ALTER TABLE CHANGG
               DROP CONSTRAINT NAAM END-EXEC
             MOVE SQLCODE TO SQL-COD
             DISPLAY "SQLCODE should be < 0; its value is ", SQL-COD
             if (SQLCODE  NOT <  0) then
               MOVE 0 TO flag
             END-IF
             DISPLAY "SQLSTATE should be 42000; its value is ", SQLSTATE
           PERFORM NOSUBCLASS THRU EXIT-NOSUBCLASS
             if (NORMSQ  NOT  =   "42000") then
               MOVE 0 TO flag
             END-IF
             if (NORMSQ   =   "42000"  AND  NORMSQ  NOT  =   SQLSTATE)
             then
               DISPLAY "Valid implementation-defined SQLSTATE accepted."
             END-IF

             DISPLAY "COMMIT WORK;"
             EXEC SQL COMMIT WORK END-EXEC
             MOVE SQLCODE TO SQL-COD

             DISPLAY  " "

      *should be able to drop CHANGG.NAAM CASCADE 
             DISPLAY "ALTER TABLE CHANGG"
             DISPLAY "  DROP NAAM CASCADE;"
             EXEC SQL ALTER TABLE CHANGG
               DROP constraint NAAM END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

             DISPLAY "COMMIT WORK;"
             EXEC SQL COMMIT WORK END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

      *verify referential constraint was a dropped object 
             DISPLAY "INSERT INTO REFERENCE_CHANGG VALUES 
      -    "('NO SUCH NAAM');"
             EXEC SQL INSERT INTO REFERENCE_CHANGG VALUES 
             ('NO SUCH NAAM') END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

             DISPLAY "COMMIT WORK;"
             EXEC SQL COMMIT WORK END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

      *TEd Hook #1  Check 11.15 SR.3 (can't drop all the columns) 
      *This is a syntax error.  If it is rejected at compile time,  
      *save the error and use the TEd hooks to remove this subtest. 
             DISPLAY "ALTER TABLE CHANGG"
             DISPLAY "  DROP NUMBRR RESTRICT;"
             EXEC SQL ALTER TABLE CHANGG
               DROP constraint NUMBRR END-EXEC
             MOVE SQLCODE TO SQL-COD
             DISPLAY "SQLCODE should be < 0; its value is ", SQL-COD
             if (SQLCODE  NOT <  0) then
               MOVE 0 TO flag
             END-IF
             DISPLAY "SQLSTATE should be 42000; its value is ", SQLSTATE
           PERFORM NOSUBCLASS THRU EXIT-NOSUBCLASS
             if (NORMSQ  NOT  =   "42000") then
               MOVE 0 TO flag
             END-IF
             if (NORMSQ   =   "42000"  AND  NORMSQ  NOT  =   SQLSTATE)
             then
               DISPLAY "Valid implementation-defined SQLSTATE accepted."
             END-IF

             DISPLAY "COMMIT WORK;"
             EXEC SQL COMMIT WORK END-EXEC
             MOVE SQLCODE TO SQL-COD
             DISPLAY  " "

      *TEd Hook #2 

             DISPLAY "DROP TABLE CHANGG CASCADE;"
             EXEC SQL DROP TABLE CHANGG CASCADE END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

             DISPLAY "COMMIT WORK;"
             EXEC SQL COMMIT WORK END-EXEC
             MOVE SQLCODE TO SQL-COD
           PERFORM CHCKOK
             DISPLAY  " "

      *11.18 SR.4 -- only the constraint, not the referencing 
      *table, was dropped. 

             DISPLAY "DROP TABLE REFERENCE_CHANGG CASCADE;"
             EXEC SQL DROP TABLE REFERENCE_CHANGG CASCADE
             END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

             DISPLAY "COMMIT WORK;"
             EXEC SQL COMMIT WORK END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

             if ( flag  =  1 ) then
               DISPLAY "                *** pass *** "
               EXEC SQL INSERT INTO HU.TESTREPORT
                 VALUES('0625','pass','PCO') END-EXEC
               MOVE SQLCODE TO SQL-COD
             else
               DISPLAY "       dml112.pco  *** fail *** "
               EXEC SQL INSERT INTO HU.TESTREPORT
                 VALUES('0625','fail','PCO') END-EXEC
               MOVE SQLCODE TO SQL-COD
               COMPUTE errcnt = errcnt + 1
             END-IF

             DISPLAY "==============================================="

             EXEC SQL COMMIT WORK END-EXEC
             MOVE SQLCODE TO SQL-COD
      ******************** END TEST0625 ********************
      ******************** BEGIN TEST0631 *******************
             MOVE 1 TO flag

             DISPLAY "                  TEST0631 "
             DISPLAY "      Datetimes in a <default clause> (static)"
             DISPLAY "References:"
             DISPLAY "    FIPS PUB 127-2 14.1 Transitional SQL feature
      -    " 5"
             DISPLAY "    11.5 <default clause>"
             DISPLAY "    6.8  <datetime value function>"
             DISPLAY "    5.3  <literal>"
             DISPLAY "   - - - - - - - - - - - - - - - - - - -"

             COMPUTE SQLCODE = -1
             MOVE "xxxxx" TO SQLSTATE

             DISPLAY "CREATE TABLE OBITUARIES ("
             DISPLAY "    NAAM CHAR (14) NOT NULL PRIMARY KEY,"
             DISPLAY "    BORN DATE DEFAULT DATE '1880-01-01',"
             DISPLAY "    DIED DATE DEFAULT CURRENT_DATE,"
             DISPLAY "    ENTERED TIMESTAMP DEFAULT CURRENT_TIMESTAMP);"

             EXEC SQL CREATE TABLE OBITUARIES (
               NAAM CHAR (14) NOT NULL PRIMARY KEY,
               BORN DATE DEFAULT '1880-01-01',
               DIED DATE DEFAULT CURRENT_DATE,
               ENTERED TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
               TESTING1 DATE,
               TESTING2 TIMESTAMP) END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

             DISPLAY "COMMIT WORK;"
             EXEC SQL COMMIT WORK END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

             DISPLAY "CREATE TABLE BIRTHS ("
             DISPLAY "    NAAM CHAR (14) NOT NULL PRIMARY KEY,"
             DISPLAY "    CHECKIN TIME (0)"
             DISPLAY "        DEFAULT TIME '00:00:00',"
             DISPLAY "    LABOR INTERVAL HOUR"
             DISPLAY "        DEFAULT INTERVAL '4' HOUR,"
             DISPLAY "    CHECKOUT TIME"
             DISPLAY "        DEFAULT CURRENT_TIME);"

             EXEC SQL CREATE TABLE BIRTHS (
               NAAM CHAR (14) NOT NULL PRIMARY KEY,
               CHECKIN TIME
               DEFAULT '00:00:00',
               LABOR TIME 
               DEFAULT '4' HOUR,
               CHECKOUT TIME
               DEFAULT CURRENT_TIME,
               TESTING TIME) END-EXEC
             MOVE SQLCODE TO SQL-COD

      *The <default option> must be a <literal> or a <datetime value  
      *function> so I can't use a CAST to change CURRENT_TIME to have 
      *no fractional seconds.                                         

           PERFORM CHCKOK
             DISPLAY  " "

             DISPLAY "COMMIT WORK;"
             EXEC SQL COMMIT WORK END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

             DISPLAY "INSERT INTO OBITUARIES (NAAM, TESTING1, TESTING2)"
             DISPLAY "  VALUES ('KEITH', CURRENT_DATE,
      -    " CURRENT_TIMESTAMP);"
             EXEC SQL INSERT INTO OBITUARIES (NAAM, TESTING1, TESTING2)
               VALUES ('KEITH', CURRENT_DATE, CURRENT_TIMESTAMP)
             END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

             DISPLAY "INSERT INTO BIRTHS (NAAM, TESTING)"
             DISPLAY "  VALUES ('BJORN', CURRENT_TIME);"
             EXEC SQL INSERT INTO BIRTHS (NAAM, TESTING)
               VALUES ('BJORN', CURRENT_TIME) END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

             DISPLAY "SELECT EXTRACT (HOUR FROM CHECKIN) +"
             DISPLAY "                EXTRACT (MINUTE FROM CHECKIN) +"
             DISPLAY "                EXTRACT (SECOND FROM CHECKIN)"
             DISPLAY "   INTO :int1 FROM BIRTHS;"

             COMPUTE int1 = -1
             EXEC SQL SELECT CHECKIN +
               CHECKIN +
               CHECKIN
               INTO :int1 FROM BIRTHS END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY "int1 should be 0; its value is ", int1
             if (int1  NOT =  0) then
               MOVE 0 TO flag
             END-IF

             DISPLAY "SELECT EXTRACT (HOUR FROM LABOR) INTO :int1 FROM
      -    " BIRTHS;"
             COMPUTE int1 = -1
             EXEC SQL SELECT LABOR INTO :int1 FROM
             BIRTHS END-EXEC
             MOVE SQLCODE TO SQL-COD
           PERFORM CHCKOK
             DISPLAY "int1 should be 4; its value is ", int1
             if (int1  NOT =  4) then
               MOVE 0 TO flag
             END-IF

             DISPLAY "SELECT COUNT (*) INTO :int1 FROM BIRTHS"
             DISPLAY "  WHERE TESTING <> CHECKOUT OR CHECKOUT IS NULL;"

             COMPUTE int1 = -1
             EXEC SQL SELECT COUNT (*) INTO :int1 FROM BIRTHS
               WHERE TESTING <> CHECKOUT OR CHECKOUT IS NULL END-EXEC
             MOVE SQLCODE TO SQL-COD
           PERFORM CHCKOK
             DISPLAY "int1 should be 0; its value is ", int1
             if (int1  NOT =  0) then
               MOVE 0 TO flag
             END-IF

             DISPLAY "SELECT COUNT (*) INTO :int1 FROM OBITUARIES"
             DISPLAY "  WHERE BORN <> DATE '1880-01-01'"
             DISPLAY "  OR BORN IS NULL"
             DISPLAY "  OR DIED <> TESTING1"
             DISPLAY "  OR DIED IS NULL"
             DISPLAY "  OR ENTERED <> TESTING2"
             DISPLAY "  OR ENTERED IS NULL;"

             COMPUTE int1 = -1
             EXEC SQL SELECT COUNT (*) INTO :int1 FROM OBITUARIES
               WHERE BORN <> '1880-01-01'
               OR BORN IS NULL
               OR DIED <> TESTING1
               OR DIED IS NULL
               OR ENTERED <> TESTING2
               OR ENTERED IS NULL END-EXEC
             MOVE SQLCODE TO SQL-COD
           PERFORM CHCKOK
             DISPLAY "int1 should be 0; its value is ", int1
             if (int1  NOT =  0) then
               MOVE 0 TO flag
             END-IF

             DISPLAY "COMMIT WORK;"
             EXEC SQL COMMIT WORK END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

             DISPLAY "DROP TABLE BIRTHS CASCADE;"
             EXEC SQL DROP TABLE BIRTHS CASCADE END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

             DISPLAY "COMMIT WORK;"
             EXEC SQL COMMIT WORK END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

             DISPLAY "DROP TABLE OBITUARIES CASCADE;"
             EXEC SQL DROP TABLE OBITUARIES CASCADE END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

             DISPLAY "COMMIT WORK;"
             EXEC SQL COMMIT WORK END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

             if ( flag  =  1 ) then
               DISPLAY "                *** pass *** "
               EXEC SQL INSERT INTO HU.TESTREPORT
                 VALUES('0631','pass','PCO') END-EXEC
               MOVE SQLCODE TO SQL-COD
             else
               DISPLAY "       dml112.pco  *** fail *** "
               EXEC SQL INSERT INTO HU.TESTREPORT
                 VALUES('0631','fail','PCO') END-EXEC
               MOVE SQLCODE TO SQL-COD
               COMPUTE errcnt = errcnt + 1
             END-IF

             DISPLAY "==============================================="

             EXEC SQL COMMIT WORK END-EXEC
             MOVE SQLCODE TO SQL-COD
      ******************** END TEST0631 ********************
      ******************** BEGIN TEST0633 *******************
             MOVE 1 TO flag

             DISPLAY "                  TEST0633 "
             DISPLAY "          TRIM function (static)"
             DISPLAY "References:"
             DISPLAY "    FIPS PUB 127-2 14.1 Transitional SQL feature
      -    " 7"
             DISPLAY "   - - - - - - - - - - - - - - - - - - -"

             COMPUTE SQLCODE = -1
             MOVE "xxxxx" TO SQLSTATE

             DISPLAY "CREATE TABLE WEIRDPAD ("
             DISPLAY "    NAAM CHAR (14),"
             DISPLAY "    SPONSOR CHAR (14),"
             DISPLAY "    PADCHAR CHAR (1));"

             EXEC SQL CREATE TABLE WEIRDPAD (
               NAAM CHAR (14),
               SPONSOR CHAR (14),
               PADCHAR CHAR (1)) END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

             DISPLAY "COMMIT WORK;"
             EXEC SQL COMMIT WORK END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

             DISPLAY "INSERT INTO WEIRDPAD (NAAM, SPONSOR) VALUES"
             DISPLAY "  ('KATEBBBBBBBBBB', '000000000KEITH');"
             EXEC SQL INSERT INTO WEIRDPAD (NAAM, SPONSOR) VALUES
               ('KATEBBBBBBBBBB', '000000000KEITH') END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

             DISPLAY "INSERT INTO WEIRDPAD (NAAM, SPONSOR) VALUES"
             DISPLAY "  ('    KEITH     ', 'XXXXKATEXXXXXX');"
             EXEC SQL INSERT INTO WEIRDPAD (NAAM, SPONSOR) VALUES
               ('    KEITH     ', 'XXXXKATEXXXXXX') END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

             MOVE "BLAHBLAHBLAHBL" TO ch2
             DISPLAY "SELECT TRIM ('X' FROM SPONSOR) INTO :ch2"
             DISPLAY "  FROM WEIRDPAD"
             DISPLAY "  WHERE TRIM (NAAM) = 'KEITH';"

             EXEC SQL SELECT TRIM (SPONSOR) INTO :ch2
               FROM WEIRDPAD
               WHERE TRIM (NAAM) = 'KEITH' END-EXEC
             MOVE SQLCODE TO SQL-COD
           PERFORM CHCKOK
             DISPLAY "ch2 should be 'KATE          '; its value is '",
             ch2 "'"

      *In languages with variable length strings, the result should 
      *not have trailing blanks.                                    
      *   if (ch2  NOT =  "KATE")                            

             if (ch2  NOT  =   "KATE          ") then
               MOVE 0 TO flag
             END-IF

      *repeat with CURSOR 
             MOVE "BLAHBLAHBLAHBL" TO ch2
             DISPLAY "DECLARE WWW CURSOR FOR "
             DISPLAY "SELECT TRIM ('X' FROM SPONSOR)"
             DISPLAY "  FROM WEIRDPAD"
             DISPLAY "  WHERE TRIM (NAAM) = 'KEITH';"

             EXEC SQL DECLARE WWW CURSOR FOR
               SELECT TRIM (SPONSOR)
               FROM WEIRDPAD
               WHERE TRIM (NAAM) = 'KEITH' END-EXEC

             DISPLAY "OPEN WWW;"
             EXEC SQL OPEN WWW END-EXEC
             MOVE SQLCODE TO SQL-COD
           PERFORM CHCKOK
             DISPLAY  " "

             DISPLAY "FETCH WWW INTO :ch2;"
             EXEC SQL FETCH WWW INTO :ch2 END-EXEC
             MOVE SQLCODE TO SQL-COD
           PERFORM CHCKOK

             DISPLAY "ch2 should be 'KATE          '; its value is '",
             ch2 "'"

      *In languages with variable length strings, the result should 
      *not have trailing blanks.                                    
      *   if (ch2  NOT =  "KATE")                            

             if (ch2  NOT  =   "KATE          ") then
               MOVE 0 TO flag
             END-IF

             MOVE "BLAHBLAHBLAHBL" TO ch2
             DISPLAY "SELECT TRIM (LEADING 'X' FROM SPONSOR) INTO :ch2"
             DISPLAY "  FROM WEIRDPAD"
             DISPLAY "  WHERE TRIM (TRAILING FROM NAAM) = '    KEITH';"

             EXEC SQL SELECT TRIM (SPONSOR) INTO :ch2
               FROM WEIRDPAD
               WHERE TRIM (NAAM) = '    KEITH' END-EXEC
             MOVE SQLCODE TO SQL-COD
           PERFORM CHCKOK
             DISPLAY "ch2 should be 'KATEXXXXXX'; its value is '", 
             ch2 "'"

      *In languages with variable length strings, the result should 
      *not have trailing blanks.                                    
      *   if (ch2  NOT =  "KATEXXXXXX")                            

             if (ch2  NOT  =   "KATEXXXXXX    ") then
               MOVE 0 TO flag
             END-IF

             MOVE "BLAHBLAHBLAHBL" TO ch2
             DISPLAY "SELECT TRIM (LEADING 'X' FROM SPONSOR) INTO :ch2"
             DISPLAY "  FROM WEIRDPAD"
             DISPLAY "  WHERE TRIM (TRAILING 'X' FROM SPONSOR) =
      -    " 'XXXXKATE';"

             EXEC SQL SELECT TRIM (SPONSOR) INTO :ch2
               FROM WEIRDPAD
               WHERE TRIM (SPONSOR) = 'XXXXKATE'
             END-EXEC
             MOVE SQLCODE TO SQL-COD
           PERFORM CHCKOK
             DISPLAY "ch2 should be 'KATEXXXXXX    '; its value is '",
             ch2 "'"

      *In languages with variable length strings, the result should 
      *not have trailing blanks.                                    
      *   if (ch2  NOT =  "KATEXXXXXX")                            

             if (ch2  NOT  =   "KATEXXXXXX    ") then
               MOVE 0 TO flag
             END-IF

             DISPLAY "SELECT TRIM (LEADING FROM B.NAAM) INTO :ch10 FROM
      -    " WEIRDPAD A,"
             DISPLAY "  WEIRDPAD B WHERE TRIM (BOTH 'B' FROM A.NAAM)"
             DISPLAY "  = TRIM (BOTH 'X' FROM B.SPONSOR);"

             MOVE "BLAHBLAHBL" TO ch10
             EXEC SQL SELECT TRIM (B.NAAM) INTO :ch10 FROM
             WEIRDPAD A,
               WEIRDPAD B WHERE TRIM (A.NAAM)
               = TRIM (B.SPONSOR) END-EXEC
             MOVE SQLCODE TO SQL-COD
           PERFORM CHCKOK
             DISPLAY "ch10 should be 'KEITH     '; its value is ", ch10
             if (ch10  NOT  =   "KEITH     ") then
               MOVE 0 TO flag
             END-IF

             DISPLAY "SELECT TRIM (LEADING FROM B.NAAM)"
             DISPLAY " INTO :ch9 :indic1 FROM WEIRDPAD A,"
             DISPLAY "  WEIRDPAD B WHERE TRIM (BOTH 'B' FROM A.NAAM)"
             DISPLAY "  = TRIM (BOTH 'X' FROM B.SPONSOR);"

             MOVE "BLAHBLAHB" TO ch9
             EXEC SQL SELECT TRIM (B.NAAM) INTO :ch9
             :indic1 FROM WEIRDPAD A,
               WEIRDPAD B WHERE TRIM (A.NAAM)
               = TRIM (B.SPONSOR) END-EXEC
             MOVE SQLCODE TO SQL-COD

             DISPLAY "SQLSTATE should be '01004'; its value is ",
             SQLSTATE
             if (SQLSTATE  NOT  =   "01004") then
               MOVE 0 TO flag
             END-IF
             DISPLAY "indic1 should be 10; its value is ", indic1
             if (indic1  NOT =  10) then
               MOVE 0 TO flag
             END-IF
             DISPLAY "ch9 should be 'KEITH    '; its value is ", ch9
             if (ch9  NOT  =   "KEITH    ") then
               MOVE 0 TO flag
             END-IF

             DISPLAY "SELECT COUNT(*) INTO :int1 FROM WEIRDPAD A,"
             DISPLAY "  WEIRDPAD B WHERE TRIM (LEADING '0' FROM
      -    " A.SPONSOR)"
             DISPLAY "  = TRIM (' ' FROM B.NAAM);"

             COMPUTE int1 = -1
             EXEC SQL SELECT COUNT(*) INTO :int1 FROM WEIRDPAD A,
               WEIRDPAD B WHERE TRIM (A.SPONSOR)
               = TRIM (B.NAAM) END-EXEC
             MOVE SQLCODE TO SQL-COD
           PERFORM CHCKOK
             DISPLAY "int1 should be 1; its value is ", int1
             if (int1  NOT =  1) then
               MOVE 0 TO flag
             END-IF

             DISPLAY "SELECT TRIM ('BB' FROM NAAM)"
             DISPLAY "  INTO :ch2 FROM WEIRDPAD WHERE NAAM LIKE
      -    " 'KATE%';"
             EXEC SQL SELECT TRIM (NAAM)
               INTO :ch2 FROM WEIRDPAD WHERE NAAM LIKE 'KATE%' END-EXEC
             MOVE SQLCODE TO SQL-COD
             DISPLAY "SQLCODE should be < 0; its value is ", SQL-COD
             DISPLAY "SQLSTATE should be 22027; its value is ", SQLSTATE
             if (SQLCODE  NOT <  0  OR  SQLSTATE  NOT  =   "22027") then
               MOVE 0 TO flag
             END-IF

      *TEd Hook #3 this may cause legitimate compilation error 
             MOVE "BB" TO ch3
             DISPLAY "SELECT TRIM (:ch3 FROM NAAM)"
             DISPLAY "  INTO :ch2 FROM WEIRDPAD WHERE NAAM LIKE
      -    " 'KATE%';"
             EXEC SQL SELECT TRIM (:ch3)
               INTO :ch2 FROM WEIRDPAD WHERE NAAM LIKE 'KATE%' END-EXEC
             MOVE SQLCODE TO SQL-COD
             DISPLAY "SQLCODE should be < 0; its value is ", SQL-COD
             DISPLAY "SQLSTATE should be 22027; its value is ", SQLSTATE
             if (SQLCODE  NOT <  0  OR  SQLSTATE  NOT  =   "22027") then
               MOVE 0 TO flag
             END-IF
      *TEd Hook #4 

             DISPLAY "INSERT INTO WEIRDPAD (NAAM, SPONSOR)"
             DISPLAY "  SELECT DISTINCT TRIM (LEADING 'D' FROM
      -    " HU.STAFF.CITY),"
             DISPLAY "                  TRIM (TRAILING 'n' FROM PTYPE)"
             DISPLAY "  FROM HU.STAFF, HU.PROJ "
             DISPLAY "  WHERE EMPNAME = 'Alice';"
             EXEC SQL INSERT INTO WEIRDPAD (NAAM, SPONSOR)
               SELECT DISTINCT TRIM (HU.STAFF.CITY), 
               TRIM (PTYPE)
               FROM HU.STAFF, HU.PROJ 
               WHERE EMPNAME = 'Alice' END-EXEC
             MOVE SQLCODE TO SQL-COD
           PERFORM CHCKOK
             DISPLAY  " "

             COMPUTE int1 = -1
             DISPLAY "SELECT COUNT(*) INTO :int1 FROM WEIRDPAD;"
             EXEC SQL SELECT COUNT(*) INTO :int1 FROM WEIRDPAD END-EXEC
             MOVE SQLCODE TO SQL-COD
           PERFORM CHCKOK
             DISPLAY "int1 should be 5; its value is ", int1
             if (int1  NOT =  5) then
               MOVE 0 TO flag
             END-IF

             MOVE "X" TO chx
             DISPLAY "UPDATE WEIRDPAD"
             DISPLAY "  SET SPONSOR = TRIM (:chx FROM SPONSOR),"
             DISPLAY "          NAAM = TRIM ('B' FROM NAAM);"
             EXEC SQL UPDATE WEIRDPAD
               SET SPONSOR = TRIM (SPONSOR),
               NAAM = TRIM (NAAM) END-EXEC
             MOVE SQLCODE TO SQL-COD
           PERFORM CHCKOK
             DISPLAY  " "

             COMPUTE int1 = -1
             DISPLAY "SELECT COUNT(*) INTO :int1 FROM WEIRDPAD"
             DISPLAY "  WHERE NAAM = 'KATE' OR SPONSOR = 'KATE';"
             EXEC SQL SELECT COUNT(*) INTO :int1 FROM WEIRDPAD
               WHERE NAAM = 'KATE' OR SPONSOR = 'KATE' END-EXEC
             MOVE SQLCODE TO SQL-COD
           PERFORM CHCKOK
             DISPLAY "int1 should be 2; its value is ", int1
             if (int1  NOT =  2) then
               MOVE 0 TO flag
             END-IF

             MOVE "Kest" TO ch2
             DISPLAY "DELETE FROM WEIRDPAD WHERE"
             DISPLAY "  TRIM(LEADING 'K' FROM :ch2) = TRIM('T' FROM
      -    " SPONSOR);"
             EXEC SQL DELETE FROM WEIRDPAD WHERE
               TRIM(:ch2) = TRIM(SPONSOR)
             END-EXEC
             MOVE SQLCODE TO SQL-COD
           PERFORM CHCKOK
             DISPLAY  " "

             COMPUTE int1 = -1
             DISPLAY "SELECT COUNT(*) INTO :int1 FROM WEIRDPAD;"
             EXEC SQL SELECT COUNT(*) INTO :int1 FROM WEIRDPAD END-EXEC
             MOVE SQLCODE TO SQL-COD
           PERFORM CHCKOK
             DISPLAY "int1 should be 4; its value is ", int1
             if (int1  NOT =  4) then
               MOVE 0 TO flag
             END-IF

             DISPLAY "UPDATE WEIRDPAD"
             DISPLAY "   SET PADCHAR = '0'"
             DISPLAY "  WHERE SPONSOR = '000000000KEITH'"
             DISPLAY "     OR NAAM    = 'eale';"
             EXEC SQL UPDATE WEIRDPAD
               SET PADCHAR = '0'
               WHERE SPONSOR = '000000000KEITH'
               OR NAAM    = 'eale' END-EXEC
             MOVE SQLCODE TO SQL-COD
           PERFORM CHCKOK
             DISPLAY  " "

             DISPLAY "UPDATE WEIRDPAD"
             DISPLAY "   SET SPONSOR = NULL"
             DISPLAY "  WHERE SPONSOR = 'Desig';"
             EXEC SQL UPDATE WEIRDPAD
               SET SPONSOR = NULL
               WHERE SPONSOR = 'Desig' END-EXEC
             MOVE SQLCODE TO SQL-COD
           PERFORM CHCKOK
             DISPLAY  " "

             COMPUTE int1 = -1
             DISPLAY "SELECT COUNT(*) INTO :int1 FROM WEIRDPAD"
             DISPLAY "  WHERE TRIM (PADCHAR FROM SPONSOR) IS NULL;"
             EXEC SQL SELECT COUNT(*) INTO :int1 FROM WEIRDPAD
               WHERE TRIM (SPONSOR) IS NULL END-EXEC
             MOVE SQLCODE TO SQL-COD
           PERFORM CHCKOK
             DISPLAY "int1 should be 2; its value is ", int1
             if (int1  NOT =  2) then
               MOVE 0 TO flag
             END-IF

             COMPUTE int1 = -1
             DISPLAY "SELECT COUNT(*) INTO :int1 FROM WEIRDPAD"
             DISPLAY "  WHERE TRIM (SPONSOR) = 'KEITH';"
             EXEC SQL SELECT COUNT(*) INTO :int1 FROM WEIRDPAD
               WHERE TRIM (SPONSOR) = 'KEITH' END-EXEC
             MOVE SQLCODE TO SQL-COD
           PERFORM CHCKOK
             DISPLAY "int1 should be 1; its value is ", int1
             if (int1  NOT =  1) then
               MOVE 0 TO flag
             END-IF

             DISPLAY "COMMIT WORK;"
             EXEC SQL COMMIT WORK END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

             DISPLAY "DROP TABLE WEIRDPAD CASCADE;"
             EXEC SQL DROP TABLE WEIRDPAD CASCADE END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

             DISPLAY "COMMIT WORK;"
             EXEC SQL COMMIT WORK END-EXEC
             MOVE SQLCODE TO SQL-COD

           PERFORM CHCKOK
             DISPLAY  " "

             if ( flag  =  1 ) then
               DISPLAY "                *** pass *** "
               EXEC SQL INSERT INTO HU.TESTREPORT
                 VALUES('0633','pass','PCO') END-EXEC
               MOVE SQLCODE TO SQL-COD
             else
               DISPLAY "       dml112.pco  *** fail *** "
               EXEC SQL INSERT INTO HU.TESTREPORT
                 VALUES('0633','fail','PCO') END-EXEC
               MOVE SQLCODE TO SQL-COD
               COMPUTE errcnt = errcnt + 1
             END-IF

             DISPLAY "==============================================="

             EXEC SQL COMMIT WORK END-EXEC
             MOVE SQLCODE TO SQL-COD
      ******************** END TEST0633 ********************
      **** TESTER MAY CHOOSE TO INSERT CODE FOR errcnt > 0
           STOP RUN.

      *    ****  Procedures for PERFORM statements

      *Test SQLCODE and SQLSTATE for normal completion. 
       CHCKOK.
             DISPLAY "SQLCODE should be 0; its value is ", SQL-COD
             DISPLAY "SQLSTATE should be 00000; its value is ", SQLSTATE
             PERFORM NOSUBCLASS THRU EXIT-NOSUBCLASS
             if (SQLCODE NOT =  0  OR   NORMSQ NOT = "00000") then
               MOVE 0 TO flag
             END-IF
             if (NORMSQ = "00000"  AND  NORMSQ NOT = SQLSTATE)
             then
               DISPLAY "Valid implementation-defined SQLSTATE accepted."
             END-IF
             .

       NOSUBCLASS.

      *This routine replaces valid implementation-defined       
      *subclasses with 000.  This replacement equates valid     
      *implementation-defined subclasses with the 000 value     
      *expected by the test case; otherwise the test will fail. 
      *After calling NOSUBCLASS, NORMSQ will be tested          
      *                          SQLSTATE will be printed.      

           MOVE SQLSTATE TO NORMSQ

           MOVE 3 TO norm1
      *subclass begins in position 3 of char array NORMSQ 
      *valid subclass begins with 5-9, I-Z, end of ALPNUM table 
           PERFORM VARYING norm2 FROM 14 BY 1 UNTIL norm2 > 36
           if (NORMSQX(norm1)  =  ALPNUM(norm2)) then
             MOVE "0" TO NORMSQX(norm1)
           END-IF
           END-PERFORM
           
      *Quit if NORMSQ is unchanged.  Subclass is not impl.-def. 
      *Changed NORMSQ means implementation-defined subclass,    
      *so proceed to zero it out, if valid (0-9,A-Z)            
           if (NORMSQ   =   SQLSTATE) then
             GO TO EXIT-NOSUBCLASS
           END-IF

           MOVE 4 TO norm1
      *examining position 4 of char array NORMSQ 
      *valid characters are 0-9, A-Z 
           PERFORM VARYING norm2 FROM 1 BY 1 UNTIL norm2 > 36
           if (NORMSQX(norm1)  =  ALPNUM(norm2)) then
             MOVE "0" TO NORMSQX(norm1)
           END-IF
           END-PERFORM
          
           MOVE 5 TO norm1
      *valid characters are 0-9, A-Z 
      *examining position 5 of char array NORMSQ 
           PERFORM VARYING norm2 FROM 1 BY 1 UNTIL norm2 > 36
           if (NORMSQX(norm1)  =  ALPNUM(norm2)) then
             MOVE "0" TO NORMSQX(norm1)
           END-IF
           END-PERFORM
   
      *implementation-defined subclasses are allowed for warnings 
      *(class = 01).  These equate to successful completion 
      *SQLSTATE values of 00000. 
      *Reference SQL-92 4.28 SQL-transactions, paragraph 2 

           if (NORMSQX(1)  =  "0"  AND  NORMSQX(2)  =  "1") then
             MOVE "0" TO NORMSQX(2)
           END-IF
           .

       EXIT-NOSUBCLASS.
           EXIT.