Cause: A string in a SQL statement, which should be delimited by single quotation marks, was not terminated properly.

Cause: The precompiler found an identifier that was too long.

Cause: A character constant with a single quotation mark was not terminated.

Cause: The precompiler found an escape sequence that it could not process inside a string literal. This error can arise when multibyte character strings that can contain shift-in or shift-out escape sequences are used.

Cause: The precompiler detected an errorin C or embedded SQL syntax. This message is followd by a more specific error message.

Cause: The precompiler could not open a header file that was specified using the #include preprocessor directive or the EXEC SQL INCLUDE statement. This can happen if the file specification is inaccurate or if read permission or read access rights on the file or on one or more of the directories in the path were not granted.

Cause: The file name length specified exceeded the maximum length. Some operating systems have a maximum file name length.

Cause: The precompiler could not open an output file. This could be a generated code output file(.c file) or a listing file. This message can result from many causes. For example: o) A pathname for a specified output file contains a non-exixtent directory. o) An operating-system error occured because the file system or disk is full. o) Write permission on the specified directory or directories in the path do not exist.

Cause: A C comment either in C code or in an embedded SQL statement, was not terminated.

Cause: This message indicates that a warning condition occured as the precompiler was doing the preprocessor pass. A more specific warning message will follow this message.

Cause: This message indicates that an error condition occured as the precompiler was in the preprocessing phase. A more specific error message will follow this message.

Cause: A string constant contains a newline character, For example char x[] = "Hello world";

Cause: The precompiler encountered an end of file while parsing an EXEC SQL statement.

Cause: The precompiler encountered an end of file while parsing a PL/SQL statement (EXEC SQL EXECUTE ...).

Cause: A user configuration file inside a user configuration file cannot be specified. That is, nested configuration files cannot be nested.

Cause: An option on the command line was specified, but a value for it was not included. For example, the offending code might look like: proc iname=sample1.pc oname=

Cause: A non existent option on the command line was specified.

Cause: A value for a command line option was incorrectly specified.

Cause: A value specified for a command line option was not within the accepted range. For example,, the range for the MAXOPENCURSORS option is 5 to 256. If a value outside the range is specified, the message is triggered.

Cause: An option name was partially specified on the command line that made it non unique. For example, % proc in=t.pc the "in" option can imply either the INAME or INCLUDE option.

Cause: A non-existent user configuration file was specified on the command line with the config option.

Cause: An option was entered inline that can only be entered on the command line or in a configuration file. For example, the offending code might look like EXEC ORACLE OPTION (NLS_CHAR=name); The NLS_CHAR option can only be entered on the command line or in a configuration file.

Cause: The system configuration file has a standard name (pmscfg.h) and a location that is operating system dependent. On UNIX systems, it is located in the ORACLE_HOME/proc directory. If a file named pmscfg.h is not found in the standard location, this warning message is issued.

Cause: An option that takes a list of values was entered. The value list did not have a closing parenthesis. This error may also occur if the list of values entered on a single line was too long and Pro*C truncated it.

Cause: The precompiler connected to Oracle but could not invoke the PL/SQL engine. This error can result if an earlier release of Oracle7 is used without the Procedural Option.

Cause: The precompiler could not open the input file. This is the .pc file specified in the INAME=option. This means that the file does not exist, that a directory was incorrectly specified in the pathname, or that the person running the precompiler does not have read permission for the file. This message could also result from operating-system errors. For example, an unmounted file system or disk I/O errors, could trigger this error.

Cause: The precompiler issues this message after a more specific message.

Cause: The username was specified on the command line without a password. For example, proc sqlcheck=full iname=sample1.pc userid=scott

Cause: The precompiler could not connect to Oracle with the username, password, and, if applicable, database link that was supplied. Note that this is a precompiler message, not a runtime message. This means that the USERID option value, either on the command line or in a configuration file, was incorrect.

Cause: The precompiler could not open the listing file. This message can result from many causes. For example, o) A pathname for a specified listing file contains a non-existent directory. o) An operating-system error occured because the file system or disk is full. o) Write permission on the specified directory has not been granted.

Cause: The USERID option was specified on the command line, but SQLCHECK was not equal to FULL or SEMANTICS. The USERID has no effect, unless SQLCHECK=FULL or SQLCHECK=SEMANTICS.

Cause: The PARSE=FULL and CODE=CPP options were both specified on the command line. The PARSE=FULL option invokes the C parser which does not understand any C++ constructs generated by the precompiler with CODE=CPP option.

Cause: UNSAFE_NULL=YES was specified on the command line, but but either the MODE was not ORACLE or the DBMS was not V7 or V8.

Cause: SQLCHECK=NONE was specified on the command line but is no longer a supported option. SQLCHECK=SYNTAX was used instead.

Cause: DBMS=V6_CHAR was specified on the command line but is no longer a supported option. The options CHAR_MAP=VARCHAR2 and DBMS=V7 were used instead.

Cause: DBMS=V6 was specified, and CHAR_MAP was specified with a value other than VARCHAR2. The CHAR_MAP value is ignored.

Cause: OBJECTS=YES was specified on the Pro*C command line, but the DBMS option value was not valid.

Cause: DBMS=V6 was specified on the command line, but is no longer a supported option value. The options DBMS=NATIVE and CHAR_MAP=VARCHAR2 were used instead.

Cause: The semantics of certain operations (such as character comparison) in Oracle version ^ are not 100% compliant with the ANSI/ISO SQL standards. When V6 semantics are requested, using the DBMS=V6 or DBMS=V6_CHAR option, precompilation with MODE=ANSI is not permitted.

Cause: An attempt was made to precompile a header file where the output data file could not be opened (or created) for writing.

Cause: An attempt was made to precompile a header file without specifying the name of the extension to use when creating the generated data file.

Cause: Semantic checking is not supported by TimesTen

Cause: This is an internal error message not usually issued.

Cause: This is an internal error message not usually issued.

Cause: This is an internal error message not usually issued. It indicates that a C string function, such as strcpy or strlen, returned an error.

Cause: A zero length option was specified on the command line.

Cause: This is a final message that the precompiler issues when information about the command line options has been requested. For example, if the command proc ? is issued to get a list of current default values for the command line options, this message appears at the end of the list.

Cause: This is an internal message for program exceptions. An unexpected condition was encountered by the command-line processor and a consistency check failed. Some possible causes of this message include: --invalid command-line options --memory corruption

Cause: An equal sign (=) was either immediately preceded or followed by a blank character.

Cause: The length of the user option exceeded 1023 bytes

Cause: An error was encounter at the given location.

Cause: An error was encounter at the given location.

Cause: The file contains an error, but could not be reopened to list or display the incorrect line.

Cause: A new source file was opened while producing the list file.

Cause: A source file was closed while producing the list file.

Cause: The error indicates that the precompiler parser encountered a badly-formed identifier or keyword.

Cause: This general message precedes one or more specific messages that detail the nature of the error.

Cause: The precompiler parser encountered a typedef statement that had no name after the type specification. For example, typedef int;

Cause: The parser can emit this message when a general syntax error occurs, for example, an unmatched '{' or '('.

Cause: EXEC SQL INCLUDE statements cannot be nested. Also, EXEC SQL INCLUDE statement cannot be put inside a file that is included using the #include preprocessor command.

Cause: The precompiler parser encountered a syntax error, either in C code or in SQL code. A more specific message should follow.

Cause: A Data Definition Language statement cannot use host variables. For example, the statement CREATE TABLE :table_name (c1 char(10)); is illegal, because the name of the table in a CREATE TABLE statement cannot be represented using host variable.

Cause: The precompiler parser encountered a #define directive that had no macro name associated with it. For example, #define

Cause: The precompiler parser encountered a #include directive that had no filename associated with it. For example, #include

Cause: A macro invocation in the source does not have the same number of arguments as the macro definition in the #define line.

Cause: C++ punctuation sequences are not supported by the ProC/C++ precompiler.

Cause: The semantic analysis phase of the precompiler could not reopen the input file to generate the output code.

Cause: Pro*C was unable to open one or both temporary files required for code generation. The user executing the precompiler must have write permission (and/or the appropriate privileges) on the current directory.

Cause: The precompiler was not able to open a header file specified using the #INCLUDE preprocessor directive or the EXEC SQL INCLUDE statement. This can happen if the file specification is inaccurate or if read permission or read-access rights on the file or on one or more of the directories in the path have not been granted.

Cause: A C function using invalid syntax was declared.

Cause: All C functions using either the traditional style (K&R style) function declarations or the new (ANSI) style must be declared; the two styles cannot be mixed.

Cause: A C function was declared with a name that is not a legal C identifier.

Cause: A function can be declared or defined using the following syntax: int func1(void) to indicate that the function has no parameters. void can be used only once in this case.

Cause: A function definition written in ANSI C must have both the name and the type for all parameters.

Cause: A formal parameter to a function was specified without giving its type.

Cause: Many C compilers allow structures to be passed to and returned from functions. Although a VARCHAR is implemented as a C struct, VARCHARs must be passed to a function as pointers.

Cause: Host variables cannot contain bit fields.

Cause: A VARCHAR variable having more that 2 dimensions was declared. Multidimensional arrays are not supported as host variables.

Cause: When a VARCHAR is declared, a length specification is mandatory. For example, the following VARCHAR declaration is meaningless, hence illegal: VARCHAR v1[];

Cause: A SIZEOF operator was used where a precompiler expression was expected. For example, as the length of a varchar.

Cause: The specified expression does not evaluate to a constant. Such expressions are required, for example, as the length of a VARCHAR.

Cause: A non-arithmetic operator was present in a constant expression.

Cause: An illegal cast is present in the expression.

Cause: The specified expression is missing the declaration of a type.

Cause: The type of a variable does not match is usage. For example, in dynamic SQL, a host variable containing the text of a SQL statement must be declared as a C character type or be equivalenced to the SQL type STRING.

Cause: The arithmetic expression must be specified with integral types.

Cause: Pointer values cannot be added, multiplied, or divided. The only arithmetic operation permitted with pointers is subtraction.

Cause: An identifier used in a SQL statement was not defined. For example, a cursor name was referenced that had not been declared, or in a DECLARE CURSOR statement, a statement name was used that had not been PREPAREd.

Cause: The name of a typedef was found where a variable was expected.

Cause: The name of a variable was found where a typedef was expected.

Cause: An attempt was made to use a non-pointer type as a pointer.

Cause: A structure component using invalid syntax was referenced. For example, a -> operator was used instead of a required `.' operator.

Cause: A scalar host variable was used in a context where a structure (or its pointer) is required.

Cause: A structure component was referenced that was not declared as part of the structure.

Cause: A function was referenced that was not declared. All function references must be declared.

Cause: The expression does not evaluate to an integer. For example, a SQL FOR expression must evaluate to an integral type.

Cause: All SQL identifiers must be declared before they are used. This message can result when a CURSOR or STATEMENT is not declared (defined) before being referenced.

Cause: A SQL identifier (such as a cursor name) can be defined only once.

Cause: A SQL statement identifier was referenced in a DECLARE... CURSOR statement that was not PREPAREd.

Cause: A cursor name was used in an OPEN, FETCH, or CLOSE statement that had not been DECLAREd.

Cause: In a Dynamic SQL Method 4 application, the DECLARE... CURSOR statement must name a statement identifier that has been PREPAREd in a preceding statement. The PREPARE statement must physically (not logically) precede the DECLARE command.

Cause: The host variable was declared using a C type that is not permitted as a host variable. See the Programmer's Guide to the Oracle Precompilers for a list of the permissible C types for host variables.

Cause: Host variable arrays of scalars with more than 1 dimension cannot be declared.The only host variables allowed to be multi-dimensioned are CHAR and VARCHAR.

Cause: A structure used as a host variable may not have structures or unions nested within it.

Cause: A C union as a host variable cannot be used.

Cause: Bit fields are not allowed in host variables because they are meaningless for database DML operations.

Cause: A host variable has an unpermitted type (i.e.; enum, void, etc).

Cause: When MODE=Oracle, a cursor defined with a WHERE CURRENT OF clause must also have a FOR UPDATE clause.

Cause: A cursor definition must be a SELECT statement.

Cause: Host variable arrays in a single statement should all be of equal size.

Cause: Embedded PL/SQL blocks require that the command-line flag SQLCHECK=SEMANTICS is used.

Cause: A database entity, such as a table or column name, was referenced, that does not exist. This is a compile time error, not a runtime error.

Cause: A PL/SQL statement was used illegally.

Cause: Indicator variables associated with host variables cannot be used in EXECIAF statements such as GET and PUT in a user exit.

Cause: In a VAR or TYPE statement, certain Oracle types require that the precision be specified. For example, VARCHAR2 or CHAR.

Cause: Datatype or variable equivalencing to the datatypes NUMBER or DECIMAL cannot be used. See the "Datatype Equivalencing" section in the Programmer's Guide to the Oracle Precompilers for more information.

Cause: The datatype specified could not be equivalenced, or the syntax was incorrect in the VAR or TYPE statement.

Cause: PL/SQL requested a bind position that does not exist.

Cause: This error message precedes a more specific error message.

Cause: The Pro*C Precompiler reads header files referenced in #INCLUDE directives and uses the values defined in them. But the precompiler never generates code using statements in header files, so use of SQL statements in these files is illegal.

Cause: A command-line option that is not used in Pro*C Release 2.0 was specified. For example, the option AREASIZE is no longer valid with precompilers used with the Oracle7 Server.

Cause: This is a generic warning message. It precedes a more specific warning.

Cause: Only objects that are lvalues (that resolve to an address) can be host variables. Because a function call is not an lvalue, one cannot be used in place of a host variable.

Cause: A declared array must be specified as the argument for an ARRAYLEN statement. Declare the array textually before the ARRAYLEN statement. See the Programmer's Guide to the Oracle Precompilers for the syntax of the ARRAYLEN statement.

Cause: The expression that specifies the ARRAYLEN dimension must evaluate to an integer. For example, the statement EXEC SQL ARRAYLEN my_array(1,3) cannot be parsed.

Cause: Arrays of some host variables types are not allowed and hence also cannot be used in ARRAYLEN statements. VARCHAR and DATE are examples.

Cause: ARRAYLEN is only valid with arrays that can be bound in PL/SQL blocks.

Cause: When MODE=ANSI is specified at precompile time, all host variables must be declared inside Declare Sections. Remember that MODE=ANSI refers to ANSI SQL, not ANSI C.

Cause: If a host variable is a structure, the associated indicator variable must also be a structure.

Cause: When a structure containing indicator variables is declared and associated with a host structure, the indicator structure must contain the same number of fields as the host structure. This is so even when some of the indicators will not be used or even when it would not make sense to do so (for fields constrained as NON NULL, for example).

Cause: An indicator array must have dimension greater than or equal to the corresponding host variable array dimension.

Cause: The semantics of certain operations (such as character comparison) in Oracle version ^ are not 100% compliant with the ANSI/ISO SQL standards. When V6 semantics are requested, using the DBMS=V6 or DBMS=V6_CHAR option, precompilation with MODE=ANSI is not permitted.

Cause: An indicator for a host variable of this type must have the C type short. An array of such indicators must be an array of shorts.

Cause: If a host variable is used to define a context name in an EXEC TOOLS GET CONTEXT or EXEC TOOLS SET CONTEXT statement, that host variable must be of a character type.

Cause: The host variable specifying an EXEC TOOLS context must be a pointer type.

Cause: f a host variable is used to define a context name in an EXEC TOOLS GET CONTEXT or EXEC TOOLS SET CONTEXT statement, that host variable must be of a character type.

Cause: The argument of a FOR clause must be specified as an integer or as an identifier containing an integer.

Cause: A SQL statement containing a SELECT command cannot contain a FOR clause. The meaning of such a statement would be unclear.

Cause: An improper declaration was placed in a Declare Section. This message is usually caused by including an EXEC SQL TYPE or EXEC SQL VAR declaration in a Declare Section.

Cause: The value given to the SQLCHECK option in an EXEC ORACLE statement in a program was greater than the value given either on the command line or greater than the default value if no SQLCHECK option was given on the command line. The order of the option values is SEMANTICS>SYNTAX>NONE. When this warning message is issued, the original value of SQLCHECK (the default or the command-line value) stays in effect.

Cause: A SQL statement other than a declarative, datatype equivalence or WHENEVER statement was found outside the body of a function when PARSE=FULL.

Cause: The DEF_SQLCODE option may not be specified if a SQLCODE declaration already explicitely appears in the program.

Cause: An array of implicit VARCHARS was declared when HOST_VARCHAR=TRUE.

Cause: A variable declared as a National Language character using the NLS_CHAR option was not declared as a char or implicit VARCHAR.

Cause: A National Language character variable (specified using the NLS_CHAR option) has undergone datatype equivalencing using either the EXEC SQL VAR or TYPE statements.

Cause: An attempt was made to connect in either SYSOPER or SYSDBA mode while at the same time trying to change passwords using the ALTER AUTHORIZATION clause in the same CONNECT statement.

Cause: NLS_CHAR was used to specify NLS multi-byte character variables without specifying MODE=ANSI.

Cause: The type of the bind variable given in a REGISTER CONNECT USING statement was not (pointer to) OCIExtProcContext.

Cause: An array declaration was given without an array length specifier.

Cause: The CHAR_MAP option was specified while indicating which host variables are to be treated by the precompiler as NLS multi-byte character variables. This mapping cannot be performed with the option NLS_LOCAL=TRUE. This error also occurs when DBMS=V6 is used in conjunction with NLS_CHAR and NLS_LOCAL=TRUE.

Cause: An explicit AT clause was used with an ALLOCATE statement or a FETCH/CLOSE statement also using a SQL_CURSOR declaration.

Cause: A host bind variable was used in an ALLOCATE, FETCH or CLOSE statement that was not declared as a result set SQL_CURSOR.

Cause: A host array was used in the WHERE clause of a SELECT-INTO statement.

Cause: A host array was used in the SELECT list of a SELECT-INTO statement.

Cause: No EXEC SQL CONTEXT USE statement was encountered and the option threads=yes was requested.

Cause: The host variable in a EXEC SQL CONTEXT USE statement or in the RETURNING clause of a REGISTER CONNECT statement was not declared to be of type SQL_CONTEXT.

Cause: A SQL DECLARE SECTION appears nested inside another one.

Cause: An executable SQL statement appears inside a DECLARE SECTION.

Cause: The values of INAME and ONAME are the same or the default output filename is the same as that specified by ONAME.

Cause: An array of some unnamed struct was used as a host variable. When using arrays of structs, the struct requires a name or tag.

Cause: An array of a struct that contained arrays of scalars or two-dimensional char or VARCHAR fields was used as a host variable.

Cause: A VARCHAR declaration was found in a file included using a #include form.

Cause: An indicator variable was used in a host/indicator variable pair for some type in a statement that did not require or need one. Typically, indicator variables are not used in ALLOCATE and FREE statements for types other than object or collection types. They are also not used in OBJECT CREATE/DEREF statements for REF types.

Cause: A CHAR_MAP option other than CHAR_MAP=VARCHAR2 was specified inline. Since DBMS=V6, this option is ignored for a character or string variable in the offending statement.

Cause: The specified host variable was not declared as a pointer type.

Cause: Host variable arrays of the specified type are not supported.

Cause: The object cache will be used for this host variable, but OBJECTS=NO was specified on the Pro*C command line.

Cause: The type of the indicator variable is not appropriate for the specified host variable.

Cause: The specified indicator variable was not declared as pointer type.

Cause: No declaration was found for the type identifier of the variable.

Cause: When using the RETURNING clause in an OBJECT CREATE statement, only a single 'REF INTO :host variable' is expected. This error occurs if the expression list to which REF belongs is greater than one or if there are more than one host variables supplied in the into list.

Cause: In an OBJECT CREATE or DEREF statement, the types of the given Object and its associated REF do not match.

Cause: The expression is not an Object type. For example, many host variable expressions in the Navigational statements require that the variable be declared of some Object type.

Cause: The expression is not a REF type. For example, some host variables in the Navigational CREATE and DEREF statements are required to be declared of some REF type.

Cause: The expression is not a Collection type. A VARRAY or Nested Table object was expected, but the given host variable did not resolve to a valid Collection type.

Cause: The type of the host variable paired with the INDICATOR descriptor item was invalid. The only permissable types for the INDICATOR item are a signed 2 byte numeric type or an indicator struct generated by the Object Type Translator for a user defined object type.

Cause: An explicit FOR clause was used in an OBJECT GET or OBJECT SET statement. Use of the FOR clause is illegal for these statements.

Cause: The number of attributes supplied in the attribute list of an OBJECT SET of GET statement does not match the total number of host variables also supplied in that statement.

Cause: An attribute given in the attribute list of an OBJECT SET or GET statement is not a member of the specified object in that statement.

Cause: An attempt was made to either GET or SET an attribute of an Object that itself was an Object or REF type.

Cause: The Object specified in an OBJECT GET or SET statement is an array which is illegal.

Cause: An illegal type conversion was attempted in a Navigational GET or SET statement between the type of the Attribute and the type of the Host Variable.

Cause: The array sizes of the Object and REF variables in an OBJECT CREATE or DEREF do not match.

Cause: An array was found in the host variable list of an OBJECT SET or GET statement.

Cause: An incomplete or perhaps missing type specification was given when declaring a host variable used in some SQL statement.

Cause: No indicator variable was provided (or matched) with a specific host variable where one was explicitely required.

Cause: An illegal value was given for the specified runtime context option in the CONTEXT option OPTION SET (or GET) statement.

Cause: The type of the host variable corresponding to a specific option value in a CONTEXT option OPTION SET (or GET) statement is invalid for that particular value.

Cause: There is a mismatch between the number of values specified and the number of valid host variables given in a CONTEXT option OPTION SET (or GET) statement.

Cause: In a LOB or Collection DESCRIBE, an Indicator Variable was used with a Host Variable when retrieving a LOB attribute that doesn't require one.

Cause: A LOB operation was attempted between LOBs whose types were not compatible. For example, When ASSIGNing one LOB to another, both LOBs must be of the same type. If they are not, this error results.

Cause: The given host variable expression was not declared to be of the required character type. In this case, one of several possible character types would have been accepted. However, the host variable type did not match any of them.

Cause: This error can occur in either of the following situations 1. An attempt to READ from a LOB into a buffer whose type was not compatible with the LOB type. 2. An attempt to WRITE a buffer into a LOB whose type was not compatible with the buffer type.

Cause: The given host variable was not declared to be an Internal LOB. BLOB, CLOB or NCLOB would have been accepted, however, the type of the host variable did not match any of these.

Cause: The given host variable was not declared to be any type of LOB, Internal or External. In addition to any Internal LOB type, BFILE would also have been accepted, however, the type of the host variable did not match any of these.

Cause: The given host variable was not declared to be an External LOB. Only BFILE would have been accepted in this case.

Cause: An attempt was made to OPEN a BFILE in READ WRITE mode. Writable BFILEs are currently not supported so this operation is considered erroneous.

Cause: The host variable and attribute pairing in a LOB or Collection DESCRIBE is invalid. Most likely, this was due to some problem with the host variable. For example, this error could occur if the host variable was not declared or is otherwise not provided.

Cause: An explicit FOR clause was used in some LOB statement. The use of the FOR clause in LOB statements is erroneous.

Cause: A request for a LOB attribute was made in a LOB DESCRIBE statement in which the given LOB was not of some Internal LOB type.

Cause: A request for a LOB attribute was made in a LOB DESCRIBE statement in which the given LOB was not an External LOB type (BFILE).

Cause: A host variable was given that was not declared to be of some acceptable binary numberic integral type. Generally, when this error occurs, a signed or unsigned integral type was expected. Floating point or otherwise imprecise numeric types are considered erroneous.

Cause: An array of collections was given in a COLLECTION statement. Only scalar (non-array) collection objects are allowed in any of the COLLECTION statements.

Cause: An illegal FOR clause was used in a COLLECTION statement that did not allow one, particularly, one of either the TRIM or DESCRIBE COLLECTION statements.

Cause: A request for a LOB attribute was made in a LOB DESCRIBE statement in which the given LOB host variable was neither an Internal an External LOB (BFILE) type.

Cause: There is a mismatch between the number of attributes and the number of valid host variables in the LOB or Collection DESCRIBE.

Cause: The value specified in the WITH MAX clause of an ALLOCATE DESCRIPTOR statement or the VALUE clause of a GET/SET DESCRIPTOR statement was either less than 1 or greater than 65535.

Cause: One of the following statements was used without specifying a DYNAMIC=ANSI command line option setting o EXEC SQL ALLOCATE/DEALLOCATE/GET/SET DESCRIPTOR o EXEC SQL DESCRIBE OUTPUT/INPUT ... USING ... descriptor o EXEC SQL EXECUTE ... INTO ... o EXEC SQL EXECUTE ... USING ... descriptor o EXEC SQL OPEN ... INTO ... o EXEC SQL OPEN ... USING ... descriptor

Cause: There was a mixing of descriptor and non-descriptor clauses in an ANSI Dynamic SQL statement.

Cause: The USING clause was used with an OPEN cursor statement where the cursor declaration was not for a PREPAREd statement. The correct sequence of statements should be as follows EXEC SQL PREPARE s FROM :stmt; EXEC SQL DECLARE c CURSOR FOR s; EXEC SQL OPEN c USING ...;

Cause: An explicit FOR clause was used in a DEALLOCATE DESCRIPTOR statement.

Cause: A destination offset was specified in a LOB WRITE APPEND statement. The destination offset is assumed to be the end of the LOB so specifying an explicit destination offset is erroneous.

Cause: A variable declared as utext, uvarchar, or longuvarchar was specified in the NLS_NCHAR command line option.

Cause: A UCS2 type has been type equivalenced in an EXEC SQL TYPE statement or a variable of UCS2 type has been type equivalenced in an EXEC SQL VAR statement.

Cause: A cursor which was not DECLAREd in SCROLL mode was used in scrollable mode in the FETCH statement.

Cause: The offset for the FETCH ABSOLUTE statement is negative.

Cause: A database entity, such as a table or column name, was referenced, that does not exist. This is a compile time error, not a runtime error.

Cause: The precompiler option OUTLINE was used without specifying SQLCHECK=SEMANTICS(FULL).

Cause: The precompiler option OUTLINEPREFIX was used without specifying OUTLINE=YES|OUTLINENAME. The precompiler option OUTLINE must be specifiied if OUTLINPREFIX is used.

Cause: The precompiler option RUNOUTLINE was used without specifying OUTLINE=YES|OUTLINENAME. The precompiler option OUTLINE must be specifiied if RUNOUTLINE is used.

Cause: Pro*C was unable to open the OUTLINE SQL file. The user executing the precompiler must have write permission (and/or the appropriate privileges) on the current directory.

Cause: Pro*C was unable to open the OUTLINE LOG file. The user executing the precompiler must have write permission (and/or the appropriate privileges) on the current directory.

Cause: Outline name value of outline option_filename_ filetype_seqno has exceeded the allowed limit.

Cause: Number of outlines that can be created has exceeded the file limit. Allowed outlines per file is 10000.

Cause: Outline cannot be created as there is syntax error; or outlines are not supported on that statement.

Cause: The precompiler option PLAN_BASELINE was used without specifying SQLCHECK=FULL.

Cause: The precompiler option PLAN_PREFIX was used without specifying PLAN_BASELINE=[<module_name>/yes].

Cause: The precompiler option PLAN_RUN was used without specifying PLAN_BASELINE=[<module_name>/yes].

Cause: Pro*C was unable to open the Plan Baseline SQL file. The user executing the precompiler must have write permission (or the appropriate privileges) on the current directory.

Cause: Pro*C was unable to open the Plan Baseline LOG file. The user executing the precompiler must have write permission (and/or the appropriate privileges) on the current directory.

Cause: Plan Baseline name <module_name>_filename_ filetype_seqno exceeded the allowed limit.

Cause: Number of Plan Baselines that can be created has exceeded the file limit. Allowed Plan Baselines per file is 10000.

Cause: Plan Baseline cannot be created, as there is a syntax error or Baselines are not supported on that statement.

Cause: Parameter required for Plan Baseline creation (PLAN_ENABLED) was used without specifying the option PLAN_BASELINE=[<module_name>/yes].

Cause: Parameter required for Plan Baseline creation (PLAN_FIXED) was used without specifying PLAN_BASELINE=[<module_name>/yes].

Cause: Both PLAN_BASELINE and OUTLINE options were specified. These options are not supported simultaneously.

Cause: SQL Plan Management (SPM) does not support module names greater than 30 bytes and the specified module name exceeded this limit.

Cause: PLAN_RUN was ignored because DECLARE TABLE was found. Baseline plans were not created during precompilation.

Cause: The numeric value was invalid.