readme.doc

orale培训教材包括了所有的sql说明和实例

        Pro*C would generate syntactic errors.  Pro*C will now accept
        such syntax, but the stringization and concatenation of the
        text will not be performed.

393628  Syntactic errors processing certain complex macro definitions

        Pro*C could not handle a macro definition of the following form
 
         #define __P(x) x
         #define foo(x) something(x, 10)
         extern int foo __P((int))
 
        The trouble was with the use of __P which previously was not
        expanded to (int) so that the foo macro could then be recognized
        and expanded in the extern declaration.
 
        This also manifested in problems with macros of the form
 
         #define __ARG1(t1, x1) (t1) t1 x1;
 
        and their subsequent use in the creation of subprograms.  The
        necessary macro expansion of such macros in odd cases would
        result in syntactic errors.

316344  Erroneous precompilation when SQL hints are incorrectly placed

        Pro*C would not precompile SQL statements that used SQL hints
        in illegal places correctly.  The resulting generated statement
        usually had the text of the hint incorrectly mixed in with the
        rest of the statement resulting in runtime errors.  SQL hints
        use the /*+ .. */ and --+ formats and must appear immediately
        following the SELECT, UPDATE, INSERT or DELETE keywords.  Any
        other placement of a hint comment is erroneous and will be
        flagged by the precompiler as a syntactic error.  This will
        force users who wish to use hints to use them correctly rather
        than accept and ignore them lulling the user into thinking that
        the hint is having an effect on the execution of the statement.

Bugs Fixed between Release 8.0.3 and Release 8.0.4
==================================================

552084  A failed attempt to logon to the database through Pro*C will
        result in a shadow process being left in the server unkilled.
        Subsequent failed attempts to logon will result in new shadow
        processes being left until either the program itself is
        terminated or the server runs out of processes.

546237  Can not connect to the database when using an explicit database
        name associated with the username in a connect string.  For
        example, trying to connect as 'scott@remote' would fail with an
        ORA-1017 error.

523931  The WHENEVER NOT FOUND condition was never checked after any of
        the various INSERT statements.  A PL/SQL trigger on an INSERT
        statement that returned NO DATA FOUND would not be trapped by a
        WHENEVER NOT FOUND condition for example.

515582  Pro*C would dump core whenever a string literal was used as a
        bind variable expression.  For example..

          EXEC SQL SELECT job INTO :job FROM emp WHERE ename = :"KING";

        Use of string literals as bind expressions is ILLEGAL and will
        now be flagged as an error by the precompiler.

509647  A core dump would result if the preceeding colon was missing on
        an attribute in a Navigational OBJECT SET statement.  This did
        not occur on the OBJECT GET however.

508256  Processing a DEREF() or REF() in a query would cause Pro*C to dump
        core depending on the platform.

506520  Pro*C would yield a syntactic error when a valid SQL hint was
        used in an INSERT statement.  Any valid hint would result in such
        an error in any form of INSERT statement.

503981  Pro*C can not handle host arrays with dynamic sql method to execute
        a pl/sql block correctly.

286765  When binding host arrays to PL/SQL tables through dynamic SQL,
        runtime errors would result.

        Host arrays used in a dynamic sql method 2 EXEC SQL EXECUTE
        statement may have two different interpretations based on the
        presence or absence of the new optional keyword EXECUTE on an
        ARRAYLEN statement.

        Please refer to Programmer's Guide to the Oracle Pro*C/C++
        Precompiler, Release 8.0.4 for more information.

217428  Having two columns in a table of type VARCHAR2(2000) was being
        incorrectly considered as two LONG columns which is not allowed.
        This prevented applications from being developed using these
        sizes for more than one VARCHAR2 column in a table.

Bugs Fixed between Release 2.2.3 and Release 8.0.3
==================================================

472139  Pro*C did not process equivalenced variable when PARSE != FULL

	Pro*C would not process a datatype equivalenced variable when
	the value of the parse option was not set to FULL.  For example

	  typedef short *sb2ptr;
	  exec sql begin declare section;
	    exec sql type sb2ptr is integer(2) reference;
	    sb2ptr ind;
	    int x;
	  exec sql end declare section;
	  ..
	  exec sql select comm into :x:ind where empno = ..;

	The generated code would take the address of ind (&ind) rather
	than reference ind directly since it really is a pointer. This
	would happen when parse != full only.

471975  Possible read from freed memory using ORACA saved statement text

        Precompiler applications that used the ORACA and requested the
        statement text could encounter memory-related problems (e.g. core
        dumps) when also using dynamic sql.  This was particularly likely to
        happen when the host variable used to hold the statement text pointed
        to dynamically allocated memory that was subsequently freed or when
        it was an automatic variable.  A side-effect of this bug fix is that
        sqlgls() no longer returns "old" statement text when called after
        a statement that is parsed by the precompiler.  For example:
                 
           EXEC SQL DECLARE C1 CURSOR FOR SELECT ENAME FROM EMP;
           EXEC SQL OPEN C1;
           sqlgls()  /* Returns "SELECT ENAME FROM EMP" */
           EXEC SQL ROLLBACK WORK RELEASE;
           sqlgls()  /* This returns NO statement text */

471039  Pro*C did not handle SQL hints in DELETE statements correctly

	Pro*C would rearrange the DELETE statement in such a way as to
	prevent any SQL hint from being used.  For example..

	   exec sql delete /*+ INDEX (emp emp_idx) */ from emp ..
	=> "delete from /*+ INDEX (emp emp_idx) */ emp .."

	Pro*C would displace the hint which would then result in it
	not being used during statement execution.

465932  Pro*C did not allow solitary ' inside a #error directive

	Pro*C would treat a single ' as the beginning of a SQL
	string literal inside preprocessor directives.

	  #error This didn't work

	Thus, Pro*C would give an error about an unterminated SQL
	string when parsing the above #error directive.

443347  Prepare before executing dynamic array gets wrong results

	When prepare of an insert statement to be used in a dynamic array
	insert and then prepare another statement containing a PL/SQL block,
	at execution it will only insert a single row.

414511  Pro*C did not allow spaces after line continuation in directives

	Spaces appearing between a line continuation and the newline
	character inside a preprocessor directive were not ignored by
	Pro*C.  For example

	  #define foo(a,b) a + \     
	  b                    123    
			       1 line continuation
				2 space(s)
				 3 newline (end of line)

	This would result in precompile errors during the preprocessing
	phase of precompilation.  Pro*C now ignores these extra spaces.

408116  Pro*C core dumps if /*+ comment with Multi-Byte characters

        Pro*C core dumps when /*+ comments contain Multi-Byte characters
        because possibility of Multi-Byte characters wasn't considered.

406516  Long PCC-F-02135 messages on command line options get chopped off

        If values of help options, such as the INCLUDE files, are very long
        and the user asks to see a help message on such an option, only part
        of the value would be shown, and in some cases a segfault would occur.

402136  ORA-1459 When inserting a NULL with a VARCHAR variable

        The message ORA-1459:invalid length for variable character string
        is returned when varchar pointers which point to zero-length
        strings are inserted into the database.

400907  Option values longer than 80 characters cause precompiler to hang

        When an option list is used, where the combined length of the list
	values exceeds 80 characters, the precompiler will hang.

397811  Array size mismatch in Array DML with 'AT :database' clause

        Pro*C would give an array size mismatch error on a DML statement
        with host arrays (of equal dimension) when an 'AT :database'
        clause was present.  Note that the DBNAME in the AT clause was
        itself a scalar host variable which was causing the mismatch.

397223  Cannot refer to a specific element of an undimensioned array

        The problem was that when a specific element of an Undimensioned
        array was used in an EXEC SQL statement as a Host variable, it gave
        a Precompiler Error.  Precompiler Error was generated to FIX the
        coredump of 215929.  With this FIX, it removes the Core dump, and
        proceeds for correct precompilation and execution, without any
        precompile.                          

382795  Pro*C can't parse "#define ident 'LOTTO'" directive

        When user uses #define ident B, Pro*C flagged an error because of
        ident, as a keyword was not allowed for #define.  (To make a note that
        ident is used as a keyword on some platforms). So, the gramamr rule 
        was changed to accomodate the use of "ident" same as other keywords
        like if, ifdef, etc.

371255  Seg Fault when pointer is invalid but indicator is null

        When a bind variable pointer is invalid and the associated
        indicator is set to -1, an access violation occurs.   

366775  Core dump precompiling with THREADS=YES - Temp files not deleted

        Although, it's user's responsibility to write code needed for
        threads=yes to work, it should NOT core dump.  With this FIX, it
        generates the semantic error message, and then tmp files are deleted.
        For example, the following error message will be generated for the
        testcase supplied with this bug:

        (1) PCC-F-02390, No EXEC SQL CONTEXT USE statement encountered

359035  NLS: Column position is not correct when comment line is generated

        When NLS char exist in a stream of chars, then due to multibyte
        column count needed to be corrected.  For example, if there are
        45 chars in a stream, out of which 2 are NLS (multibyte), then
        in reality there are only 43 chars.  If 45 is used, then it will
        fetch next 2 bytes, which might happen to be the beginning of
        comment /*.  This will mess up the whole comment structure.  So
        the number of correct char. counts is calculated with this fix.

345010  Pro*C could not handle use of the ANSI token merging operator

        Using the merging operator '##' would cause Pro*C to generate
        spurious syntactic error messages.  The syntax is now accepted
        but the merging is not done.  Pro*C will accept the use of the
        operator but will not support the functionality.

344346  Precompiler help screen loops infinitely for some NLS languages

        When requesting the help screen, precompiler would loop infinitely
        for certain NLS languages in which the description of the command     
        line option was excessively long, without intervening spaces so much
        so that it could't fit on a single line without being broken up into
	multiple lines.

268198  Pro*C did not allow split of EXEC SQL BEGIN/END DECLARE SECTION

        Pro*C required that EXEC SQL BEGIN/END DECLARE SECTION be
        written all on one line with the possibility of splitting it
        across multiple lines.  Syntactic errors would result otherwise.

479063  Spurious runtime errors when using arrays of LOB types

        The precompiler produced incorrect code when processing certain
        array declarations of LOB types, particularly when they appeared in
        a function parameter list.  For example, the following statement
        was not precompiled correctly:

               void BlobFunc(multi_blob)       
                 OCIBlobLocator *multi_blob[];

475284  Pro*C dumped core after generating certain error messages

        Pro*C would dump core after finding certain errors related to
        the use of bind variables declared to be of some new Objects
        related types (ie; OCINumber).  This would also happen due to
        the fact that an Objects program was being precompiled without
        specifying an INTYPE file.

469671  Pro*C dumped core when processing long lines of Multibyte text
              
        For excessively long lines of input having a lot of Multibyte
        text, Pro*C would terminate abnormally with a core dump.

464714  The FIPS report showed all violations occured at line 0 (zero)
             
        The FIPS report generated by Pro*C would indicate that all