36 PLS-00049 to PLS-01913

Cause: The client (caller) of PL/SQL has parsed a bind variable that it has informed to be "bad".

Cause: This error message is not used yet. (Heh, heh, that"s a joke, son.)

Cause: The parser, which checks the syntax of PL/SQL statements, uses a data structure called a stack; the number of levels of nesting in the PL/SQL block exceeded the stack capacity.

Cause: This error message is from the parser. It found a token (language element) that is inappropriate in this context.

Cause: In a subprogram call, the name of the subprogram was followed by an empty parameter list. For example, procedure P was called as P(). This is not allowed.

Cause: More than one forward declaration of a type is redundant.

Cause: While checking a declarative unit (a top-level declare block without the BEGIN...END), PL/SQL found that there was more than one item declared or that the item was not a variable declaration. A table is a common variable declaration at the unit level. To define a TABLE, compile a DECLARE compilation unit, but only one at a time is allowed.

Cause: No declaration for the exception name referenced in an EXCEPTION_INIT pragma was found within the scope of the pragma.

Cause: A bind variable, that is, an identifier prefixed with a colon, was found in an inappropriate context.

Cause: A Comment had a comment initiator (/*), but before the

Cause: A quoted identifier had a beginning quote ("), but before the ending quote (") was found, an end-of-line marker was encountered.

Cause: Following the keyword END, which terminates some language constructs (such as loops, blocks, functions, and procedures), you can optionally place the name of that construct. For example, at the end of the definition of loop L you might write END L. This error occurs when the optional name does not match the name given to the language construct. It is usually caused by a misspelled identifier or by faulty block structure.

Cause: The name of a PL/SQL variable is longer than 30 characters. Legal identifiers (including quoted identifiers) have a maximum length of 30 characters. A string literal might have been mistakenly enclosed in double quotes instead of single quotes, in which case PL/SQL considers it a quoted identifier.

Cause: The pragma refers to a PL/SQL object that was not declared or is not within the scope of the reference. Identifiers must be declared before they are used in a pragma; forward references are not allowed.

Cause: Two or more WHERE clauses were found in a DELETE, SELECT, or UPDATE statement. The WHERE clause specifies a condition under which rows in a table are processed. The condition can contain several logical expressions connected by AND or OR, but a statement can contain only one WHERE clause.

Cause: Two or more CONNECT BY clauses were found in a SELECT statement. The CONNECT BY clause defines a relationship used to return rows in a hierarchical order. The relationship can contain two expressions separated by a relational operator (such as = or !=), but a statement can contain only one CONNECT BY clause.

Cause: Two or more GROUP BY clauses were found in a SELECT statement. The GROUP BY clause lists column expressions used to form a summary row for each group of selected rows. The list can contain several column expressions separated by commas, but a statement can contain only one GROUP BY clause.

Cause: Two or more HAVING clauses were found in a SELECT statement. The HAVING clause specifies a condition under which groups of rows (formed by the GROUP BY clause) are included in the result. The condition can include several logical expressions connected by AND or OR, but a statement can contain only one HAVING clause.

Cause: The asterisk (*) option was used in the argument list of a SQL group function other than COUNT. For example, the code might look like SELECT SUM(*) INTO emp_count FROM emp; -- should be COUNT(*) Only COUNT permits the use of the asterisk option, which returns the number of rows in a table.

Cause: A few built-in functions use keywords (instead of commas) as argument separators: Built-in function Argument separators --------------------------------------------- CHR, TRANSLATE USING CAST AS TRIM TRAILING, LEADING, BOTH, FROM A function different from one of these built-in functions is using a keyword as an argument separator.

Cause: PL/SQL was designed primarily for robust transaction processing. One consequence of the special-purpose design is that the PL/SQL compiler imposes a limit on block size. The limit depends on the mix of statements in the PL/SQL block. Blocks that exceed the limit cause this error.

Cause: The first argument passed to the EXCEPTION_INIT pragma was something other than an exception name. The first argument must be the name of a legally declared exception.

Cause: When a constant or variable was declared, its datatype was not specified. For example, the code might look like pi CONSTANT := 3.14159; -- should be CONSTANT REAL := 3.14159 Every constant and variable must have a datatype, which specifies a storage format, constraints, and valid range of values.

Cause: The ALL shortcut for specifying system privileges or statement options was used in a SQL statement. PL/SQL does not support the ALL shortcut.

Cause: The named pragma (compiler directive) is not among those supported by PL/SQL. The pragma name might be misspelled, or the pragma syntax might be faulty.

Cause: The number of arguments (actual parameters) passed to the named pragma (compiler directive) is incorrect. A required argument was omitted from the argument list, or the pragma syntax is faulty (for example, a comma might be missing between two parameters).

Cause: The first parameter passed to pragma INTERFACE specified a host language other than C. Currently, C is the only host language supported. The parameter might be misspelled, or the pragma syntax might be faulty (for example, a comma might be missing between two parameters).

Cause: The first argument (actual parameter) passed to the named pragma (compiler directive) was not the name of a subprogram, package, or cursor, as required. The parameter might be misspelled, or the pragma syntax might be faulty (for example, a comma might be missing between two parameters).

Cause: The second argument (actual parameter) passed to the named pragma (compiler directive) was not the name of a procedure, as required. The parameter might be misspelled, or the pragma syntax might be faulty (for example, a comma might be missing between two parameters).

Cause: One of the parameters passed to pragma RESTRICT_REFERENCES was not among the following, as required: WNDS, WNPS, RNDS, RNPS. The parameter might be misspelled, or the pragma syntax might be faulty (for example, a comma might be missing between two parameters)

Cause: The first argument (actual parameter) passed to the named pragma (compiler directive) was not an identifier or string literal, as required. The parameter might be misspelled, or the pragma syntax might be faulty (for example, a comma might be missing between two parameters).

Cause: The second argument (actual parameter) passed to the named pragma (compiler directive) was not an identifier or string literal, as required. The parameter might be misspelled, or the pragma syntax might be faulty (for example, a comma might be missing between two parameters).

Cause: The fourth argument (actual parameter) passed to the named pragma (compiler directive) was not a numeric literal, as required. The parameter might be miscoded, or the pragma syntax might be faulty (for example, a comma might be missing between two parameters).

Cause: Invalid precision was specified for a signed or unsigned binary type.

Cause: The subprogram was found to have two external NAME specifications.

Cause: The subprogram was found to have two external LIBRARY specifications.

Cause: The subprogram was found to have two external PARAMETER STYLE specifications.

Cause: The subprogram was found to have two external PARAMETER STYLE specifications.

Cause: The subprogram was found to have two external LANGUAGE specifications.

Cause: The subprogram was found to have two external CALLING STANDARD specifications.

Cause: The subprogram was found to have two external WITH CONTEXT specifications.

Cause: The subprogram was found to have two external TRUSTED/UNTRUSTED specifications.

Cause: A zero-length string was found for the LIBRARY file specification.

Cause: The subprogram was found to have two PRAGMA RESTRICT_REFERENCES.

Cause: This error happens in the creation of a pl/sql external type: [SIGNED | UNSIGNED] BINARY INTEGER (<precision>). It may be referenced only in a create type statement. Such types are non-queryable. Something other than "INTEGER" was supplied.

Cause: A type was used which does not belong PL/SQL. This type can only be referenced in CREATE TYPE statements, and is a non-queryable data type.

Cause: A POINTER type which does not belong to PL/SQL can only refer to an object type. This type can only be referenced in CREATE TYPE statements, and is a non-queryable data type.

Cause: A POINTER or [SIGNED/UNSIGNED] BINARY INTEGER can only be used as attributes of object types. These types can only be referenced in CREATE TYPE statements, and are non-queryable data types. One of these external PL/SQL types outside of an object type.

Cause: More than one map or order function was declared. An object type can have only one map function or one order function, but not both.

Cause: A procedure was declared as a MAP, ORDER or CONSTRUCTOR method. Only functions can be MAP, ORDER or CONSTRUCTOR methods.

Cause: A null constraint was specified for an attribute in an object. This is not supported.

Cause: An AUTHID clause was specified for a subprogram inside a package or type. These clauses are only supported for top-level stored procedures, packages, and types.

Cause: The only two allowed options for AUTHID are CURRENT_USER and DEFINER.

Cause: The third argument (actual parameter) passed to the named pragma (compiler directive) was not an identifier or a string literal when there is a fourth argument to the pragma. The parameter might be misspelled, or the pragma syntax might be faulty (for example, a comma might be missing between two parameters).

Cause: The fourth argument (actual parameter) passed to the named pragma (compiler directive) was not a numeric literal, as required. The parameter might be misspelled, or the pragma syntax might be faulty (for example, a comma might be missing between two parameters).

Cause: This feature is not yet implemented.

Cause: A CALL statement was found in PL/SQL source.

Cause: The contents of the date, time or timestamp literal did not match the expected format "yyyy-mm-dd hh24:mi:ssxfftzh:tzm".

Cause: keyword BULK is used illegally. For example, BULK is used without INTO clause

Cause: A method or object type modifier was specified more than once.

Cause: The method or object type modifier specified conflicts with an earlier modifier. For example, a FINAL modifier cannot be combined with a NOT FINAL modifier.

Cause: An OPEN cursor statement or cursor FOR loop can only invoke a SELECT statement, not an UPDATE, INSERT or DELETE.

Cause: The subprogram was found to have two dedicated AGENT specifications.

Cause: The string literal was longer than 32767 bytes.

Cause: SPACE, TAB or RETURN was used as alternative quote delimiter.

Cause: The expression contained a syntax or semantic error, or it did not have a boolean type or its evaluation raised an exception.

Cause: A preprocessor token was used inappropriately.

Cause: A preprocessor directive was not ended properly.

Cause: The expression contained a syntax or semantic error, or it did not have a character type or its evaluation raised an exception.

Cause: $ERROR directive was used. This is an expected error message.

Cause: A preprocessor directive was used in a compilation unit for which conditional compilation is not supported.

Cause: An unsupported preprocessor directive was used.

Cause: You tried to reference either an undeclared variable, exception, procedure, or other item, or an item to which no privilege was granted or an item to which privilege was granted only through a role.

Cause: An attempt was made to reference an undefined type. Either the type specifier was not declared or it is not within the scope of the reference.

Cause: Less than three arguments were passed to the built-in function DECODE. Though DECODE takes a variable number of (non-Boolean) arguments, at least three arguments must be passed.

Cause: A pseudocolumn or proscribed function was used in a procedural statement. The SQL pseudocolumns (CURRVAL, LEVEL, NEXTVAL, ROWID, ROWNUM) can be used only in SQL statements. Likewise, certain functions such as DECODE, DUMP, and VSIZE and the SQL group functions (AVG, MIN, MAX, COUNT, SUM, STDDEV, VARIANCE) can be used only in SQL statements.

Cause: An aggregate, that is, a parenthesized list of values such as (7788, "SCOTT", 20), was found in an inappropriate context.

Cause: The program object declared using the %TYPE datatype attribute is not of the appropriate class. It must be a variable, column, record component, subprogram formal parameter, or other object to which values can be assigned.

Cause: An identifier that is not a cursor attribute was applied to the identifier SQL. For example, this error occurs if the cursor attribute is misspelled.

Cause: An identifier not declared as a cursor attribute was applied to an identifier declared as a cursor. For example, this error occurs if the cursor attribute is misspelled.

Cause: In a query, a table referenced by the select list is not named in the FROM clause.

Cause: Unless the clauses of a CASE statement mention all values of the type of the selecting expression, an OTHERS clause must be provided as the last clause of the CASE statement. It is impossible to cover all values of type INTEGER (or NUMBER), so an OTHERS clause is always required when the expression following the keyword CASE is of type INTEGER (or NUMBER).

Cause: In this CASE statement, a value appears in more than one WHEN clause. A value may appear in at most one WHEN clause of a CASE statement.

Cause: The CASE statement is too big. The compiler did not have enough storage to process it.

Cause: The PL/SQL compiler could not find package STANDARD in the current Oracle database. To compile a program, PL/SQL needs package STANDARD.

Cause: The number of levels of nesting in the PL/SQL block is too large. Blocks can be nested up to 255 levels deep, depending on the availability of system resources such as memory.

Cause: When a character variable was declared, a length outside the legal range was specified. For example, the following declarations are illegal: flag CHAR(0); -- illegal; zero length name VARCHAR2(-10); -- illegal; negative length

Cause: A NUMBER variable was declared with a precision that is outside the legal range. Declarations such as N NUMBER(800) or N NUMBER(123,10) are not supported.

Cause: A NUMBER variable was declared with a scale that is outside the legal range. Declarations such as N NUMBER(10,345) or N NUMBER(10,-100) are not supported.

Cause: In general, variables that have no initialization clause in their declaration are automatically initialized to NULL. This is illogical for NOT NULL variables; therefore, an initialization clause is required.

Cause: A block or loop label was used to qualify a variable (as in outer_block.date) that was not declared or is not within the scope of the label. The variable name might be misspelled, its declaration might be faulty, or the declaration might be placed incorrectly in the block structure.

Cause: A qualified name such as A.B or A.B.C is not permitted here.

Cause: An identifier being referenced as a procedure was not declared or actually represents another object (for example, it might have been declared as a function).

Cause: An identifier being referenced as a function was not declared or actually represents another object (for example, it might have been declared as a procedure).

Cause: An identifier being referenced as a parameterless function actually represents a procedure.

Cause: An identifier being referenced as a function or an array actually represents an object (a number or date, for example) that cannot be referenced in this way.

Cause: The prefix in a qualified name was a subprogram or cursor which was not in an enclosing scope; i.e., a subprogram or cursor name is being used as a scope qualifier for a reference to an entity (within that subprogram or cursor) that is not in scope. Example: declare x number; type t1 is record (a number); function f return t1 is a number; begin x := f.a; -- legal use of function "f" as a scope qualifier; -- resolves to local variable "a" in function "f". x := f().a; -- legal reference to component "a" of returned record end; begin x := f.a; -- illegal use of function "f" as a scope qualifier x := f().a; -- legal reference to component "a" of returned record end;

Cause: A package was referenced in an expression as if it were a variable or function. Either the name of the variable or function is misspelled or the reference is not fully qualified. For example, to call the function my_function, which is stored in package my_package, dot notation must be used, as follows: ... my_package.my_function ...

Cause: When the formal parameters of a subprogram were declared, one parameter was used to initialize another, as in PROCEDURE my_proc (j NUMBER, k NUMBER := j) IS ... The first parameter has no value until run time, so it cannot be used to initialize another parameter.

Cause: The identifier is a formal parameter which is being used in the context of a default expression value for a formal parameter in the same formal parameter list. E.g.: procedure p(j number, k number := j).

Cause: An attribute expression, such as SQL%NOTFOUND, was used in a SQL statement, but attribute expressions are allowed only in procedural statements.

Cause: When the formal parameters of a procedure were declared, an OUT or IN OUT parameter was initialized to a default value, as in PROCEDURE calc_bonus (bonus OUT REAL := 0, ...) IS ... However, only IN parameters can be initialized to default values.

Cause: A proscribed function was used in a SQL statement. Certain functions such as SQLCODE and SQLERRM can be used only in procedural statements.

Cause: A package was declared inside another package, but package declarations are allowed only at the top level. In other words, packages cannot be nested.

Cause: The WHEN clause in an exception handler contains a function call instead of an exception name. A valid exception handler consists of a WHEN clause, which must specify an exception, followed by a sequence of statements to be executed when that exception is raised.

Cause: A subprogram cannot specify both PARAMETER STYLE SQL and an explicit PARAMETERS list. Use PARAMETER STYLE GENERAL to supply default PARAMETERS list types.

Cause: An unsuccessful attempt was made to convert a parameter to the specified external parameter type.

Cause: The external type specified is not valid for one of the following: INDICATOR, LENGTH, MAXLEN, TDO, DURATION, CHARSETID, or CHARSETFORM.

Cause: BY VALUE was specified with an indicator or length parameter that is being passed in OUT or IN OUT mode. Only IN mode parameters may be passed by value.

Cause: An external parameter name was specified that does not match one in the formal parameter list.

Cause: An inappropriate external parameter type was specified for the SQLCODE parameter.

Cause: An inappropriate external parameter type was specified for the RETURN indicator, LENGTH, TDO, or DURATION.

Cause: An inappropriate external parameter type was specified for the SQLSTATE parameter.

Cause: An inappropriate external parameter type was specified for the CONTEXT parameter.

Cause: An inappropriate external parameter type was specified for the SQLNAME parameter.

Cause: There are multiple declarations of at least one the following FORMAL, INDICATOR, LENGTH, MAXLENGTH, or CONTEXT. PL/SQL allows only one declaration of the above for each formal parameter in the PARAMETERS clause.

Cause: There are multiple declarations of the formal parameter in the PARAMETERS clause. PL/SQL allows only one declaration of the formal parameter in the PARAMETERS clause.

Cause: A PARAMETER STYLE clause was placed in the external subprogram body.

Cause: The LIBRARY name is missing from the external subprogram body.

Cause: The LIBRARY syntax was entered incorrectly.

Cause: CONTEXT was used in a WITH CONTEXT or a PARAMETERS clause. This is invalid.

Cause: The usage of Keywords such as MAXLEN, LENGTH, CHARSETID, CHARSETFORM RETURN in the parameters clause was incorrect

Cause: RETURN specification for the actual function return, used within the parameters clause must hold the very last position. Example : The following will give this error since the RETURN specification for the actual function return in the parameters clause is not the last. FUNCTION myexternalfunc (var1 BINARY_INTEGER, var2 BINARY_INTEGER) RETURN BINARY_INTEGER IS EXTERNAL NAME "myexternalfunc" LIBRARY somelib PARAMETERS (var1 LONG, var2 SHORT, RETURN INT, RETURN INDICATOR SHORT); The correct syntax is the following. Note that RETURN for actual function return is the last specification in the parameters clause. FUNCTION myexternalfunc (var1 BINARY_INTEGER, var2 BINARY_INTEGER) RETURN BINARY_INTEGER IS EXTERNAL NAME "myexternalfunc" LIBRARY somelib PARAMETERS (var1 LONG, var2 SHORT, RETURN INDICATOR SHORT, RETURN INT);

Cause: A reference is made to the fixed package version of STANDARD when the database is open, or to the on-disk version when the database is closed. Explicit use of a SYS.X$ package name can lead to this. One might also see this from a compilation that begins while the db is closed but has the bad luck to have another session open the db before compilation is complete. Another possible cause is having "set serveroutput on" through svrmgrl when doing an "alter database close".

Cause: The parameter clause does not have a matching parameter for a parameter specified in the formal parameter list.

Cause: actual parameter mode (OUT, or IN/OUT) is not used properly in USING clause. For USING clause in an OPEN statement, only IN mode is allowed.

Cause: CALL Specification formal parameters default values are disallowed.

Cause: The supplied external library name in the external clause is not a valid alias library.

Cause: An EXTERNAL Clause was detected in a TYPE Specification or a PACKAGE specification.

Cause: A call specification for C or Java cannot have constraints on the PL/SQL formal parameter types. PL/SQL types which have have constraints are NATURAL, NATURALN, POSITIVE, POSITIVEN, SIGNTYPE, INTEGER, INT, SMALLINT, DECIMAL, NUMERIC, DEC This includes NOT NULL constraints from POSITIVEN, NATURALN

Cause: It is mandatory to specify the rights model if a PL/SQL PROCEDURE, FUNCTION, PACKAGE OR TYPE HAS CALL-Specifications

Cause: A Datetime/Interval variable or attribute was declared with a constraint outside the legal range.

Cause: A call specification declaring that an implementation is in Java has been found for a method of an object or opaque type. This usage is not yet supported.

Cause: In a reference to a component (for example, in the name "A.B", "B" is a component of "A"), the component has not been declared. The component might be misspelled, its declaration might be faulty, or the declaration might be placed incorrectly in the block structure.

Cause: In a name such as "A.B", "A" is the qualifier, and "B" is a component of the qualifier. This error occurs when no declaration for the qualifier is found.The qualifier might be misspelled, its declaration might be faulty, or the declaration might be placed incorrectly in the block structure.

Cause: The compiled package specification required to compile a package body could not be found. Some possible causes follow: --the package name is misspelled --the package specification was never compiled --the compiled package specification is not accessible The package specification must be compiled before compiling the package body, and the compiler must have access to the compiled specification.

Cause: While looking for prior declarations of a cursor, procedure, function, or package, the compiler found another object with the same name in the same scope. Or, the headers of subprogram in a package specification and body do not match word for word.

Cause: This error occurs when the named subprogram call cannot be matched to any declaration for that subprogram name. The subprogram name might be misspelled, a parameter might have the wrong datatype, the declaration might be faulty, or the declaration might be placed incorrectly in the block structure. For example, this error occurs if the built-in square root function SQRT is called with a misspelled name or with a parameter of the wrong datatype.

Cause: The declaration of a subprogram or cursor name is ambiguous because there was no exact match between the declaration and the call and more than one declaration matched the call when implicit conversions of the parameter datatypes were used. The subprogram or cursor name might be misspelled, its declaration might be faulty, or the declaration might be placed incorrectly in the block structure.

Cause: The construct or expression does not designate a value that can be assigned to a variable. For example, the datatype name NUMBER cannot appear on the right hand side of an assignment statement as in X := NUMBER.

Cause: The "%LAST" attribute must be applied to an identifier that has been declared as a variable of an enumerated type (or subtype of an enumerated type). This error occurs when "%LAST" follows some identifier that has not been so declared.

Cause: The %ROWTYPE attribute must be applied to an identifier declared as a cursor, cursor variable, or database table. This error occurs when %ROWTYPE follows some identifier that has not been so declared.

Cause: This occurrence of the identifier cannot be compiled because its type has not been properly defined.

Cause: When a list of parameters is passed to a subprogram or cursor, if both positional and named associations are used, all positional associations must be placed in their declared order and before all named associations, which can be in any order.

Cause: There is no declaration for the given identifier within the scope of reference. The identifier might be misspelled, its declaration might be faulty, or the declaration might be placed incorrectly in the block structure.

Cause: In a precompiled program, the DECLARE TABLE statement was mistakenly used inside an embedded PL/SQL block. If an embedded PL/SQL block refers to a database table that does not yet exist, use the DECLARE TABLE statement to tell the precompiler what the table will look like. However, DECLARE TABLE statements are allowed only in the host program.

Cause: In the INDEX BY clause of a PL/SQL table declaration, a datatype other than BINARY_INTEGER, PLS_INTEGER, or VARCHAR2 was specified. PL/SQL tables can have one column and a primary key. The column can have any scalar type, but the primary key must be either a binary integer type or VARCHAR2.

Cause: In the INDEX BY clause of a PL/SQL table declaration, a composite primary key was specified. PL/SQL tables must have a simple, unnamed primary key of a binary integer or VARCHAR2 type.

Cause: An incomplete type declaration was not completed in the declarative region where it was declared.

Cause: A type-declaration such as: -- a non-REF recursive type, for example: type t is record (a t); or -- non-REF mutually dependent types, for example: type t1; type t2 is record (a t1); type t1 is record (a t2); was performed. In these examples, the type is malformed because it participates in a mutually recursive non-REF relationship with itself and possibly other types.

Cause: An invalid expression such as X IN (SELECT A,B ...) was used. When a [NOT]IN clause is used with a subquery, it does not test for set membership. The number of expressions in the [NOT]IN clause and the subquery select list must match. So, in the example above, the subquery must specify at most one column.

Cause: In a declaration, the name of a variable or cursor is misspelled or the declaration makes a forward reference. Forward references are not allowed in PL/SQL. A variable or cursor must be declared before it is referenced it in other statements, including other declarative statements. For example, the following declaration of dept_rec raises this exception because it refers to a cursor not yet declared: DECLARE dept_rec dept_cur%ROWTYPE; CURSOR dept_cur IS SELECT ... ...

Cause: The expression does not designate a variable that can have a value assigned to it. For example, the function SYSDATE cannot appear on the left hand side of an assignment statement such as SYSDATE := "01-JAN-1990";

Cause: A constant declaration lacks the assignment of an initial value. For example, in the following declaration" := 3.14159" is the initialization clause: "pi constant number := 3.14159;"

Cause: A subprogram specification was placed in a package specification, but the corresponding subprogram body was not placed in the package body. The package body implements the package specification. So, the package body must contain the definition of every subprogram declared in the package specification.

Cause: This error occurs when a cursor-attribute ("%FOUND", "%NOTFOUND", "%ROWS", "%IS_OPEN", etc.) appears following an identifier that is not declared as a cursor or cursor variable. It occurs, for example, if the variable name my_cur in my_cur%FOUND was not properly declared as a cursor or if the variable declaration was placed incorrectly in the block structure.

Cause: A non-integral numeric literal was used in a context that requires an integer (a number with no digits to the right of its decimal point).

Cause: The number of expressions in an IN clause did not equal the number of expressions in a corresponding subquery select list. For example, the following statement is invalid because the IN clause contains two expressions, but the subquery select list contains just one: ... WHERE (ename, sal) IN (SELECT sal FROM emp);

Cause: In a SQL statement, a reference was made to an out-of-scope database object. The referenced object might be misspelled, or the reference might be mixed, as in the following example: CURSOR c1 IS SELECT dept.dname FROM emp;

Cause: A subprogram specification was declared, but the corresponding subprogram body was not defined. Write the subprogram specification and body as a unit. An alternative solution is to separate the specification from its body, which is necessary when you want to define mutually recursive subprograms or you want to group subprograms in a package.