Overblog Suivre ce blog
Editer la page Administration Créer mon blog
/ / /

 

PLS PLSQL ERROR CODE ORACLE.

 

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

 

PLS-00101 PLS-00101: reserved for future use
Cause This error message is not used yet. (Heh, heh, that"s a joke, son.)
Action none

 

PLS-00102 PLS-00102: parser stack overflow because nesting is too deep
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.
Action Reorganize the block structure to avoid nesting at too deep a level. For example, move the lowest-level sub-block to a higher level.

 

PLS-00103 PLS-00103: %s
Cause This error message is from the parser. It found a token (language element) that is inappropriate in this context.
Action Check previous tokens as well as the one given in the error message. The line and column numbers given in the error message refer to the end of the faulty language construct.

 

PLS-00104 PLS-00104: empty argument list in call of procedure "string" must be omitted
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.
Action Remove the empty parameter list. In the example, change the procedure call to P.

 

PLS-00105 PLS-00105: at most one forward declaration of type "string" is permitted
Cause More than one forward declaration of a type is redundant.
Action Remove all but one forward declaration.

 

PLS-00108 PLS-00108: declarative units must be a single variable declaration
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.
Action Declare variables in separate declarative units.

 

PLS-00109 PLS-00109: unknown exception name "string" in PRAGMA EXCEPTION_INIT
Cause No declaration for the exception name referenced in an EXCEPTION_INIT pragma was found within the scope of the pragma.
Action Make sure the pragma follows the exception declaration and is within the same scope.

 

PLS-00110 PLS-00110: bind variable "string" not allowed in this context
Cause A bind variable, that is, an identifier prefixed with a colon, was found in an inappropriate context.
Action Remove the colon or replace the bind variable with the appropriate object.

 

PLS-00111 PLS-00111: end-of-file in comment
Cause A Comment had a comment initiator (/*), but before the
Action Remove the Comment initiator or add a comment terminator. The line and column numbers accompanying the error message refer to the beginning of the last legal token before the Comment initiator.

 

PLS-00112 PLS-00112: end-of-line in quoted identifier
Cause A quoted identifier had a beginning quote ("), but before the ending quote (") was found, an end-of-line marker was encountered.
Action Remove the beginning quote or add the ending quote. The line and column numbers accompanying the error message refer to the beginning of the quoted identifier.

 

PLS-00113 PLS-00113: END identifier "string" must match "string" at line string, column string
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.
Action Make sure the spelling of the END identifier matches the name given to the language construct and that the block structure is correct.

 

PLS-00114 PLS-00114: identifier "string" too long
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.
Action Shorten the identifier.

 

PLS-00115 PLS-00115: this PRAGMA must follow the declaration of "string"
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.
Action Check the spelling and declaration of the identifier. Also confirm that the declaration is placed correctly in the block structure.

 

PLS-00116 PLS-00116: Duplicate where-clause in table expression
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.
Action Remove one of the WHERE clauses and, if necessary, connect logical expressions by AND or OR

 

PLS-00117 PLS-00117: Duplicate connect-by clause in table expression
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.
Action Remove one of the CONNECT BY clauses and, if necessary, separate expressions by a relational operator.

 

PLS-00118 PLS-00118: Duplicate group-by clause in table expression
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.
Action Remove one of the GROUP BY clauses and, if necessary, separate column expressions by commas.

 

PLS-00119 PLS-00119: Duplicate having-clause in table expression
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.
Action Remove one of the HAVING clauses and, if necessary, connect logical expressions by AND or OR.

 

PLS-00120 PLS-00120: inappropriate argument in OPEN statement
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.
Action Remove the asterisk option from the argument list and replace it with an expression that refers to one or more database columns.

 

PLS-00122 PLS-00122: %s as separator is allowed only with specific built-in functions
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.
Action Correct the argument list or change the function name.

 

PLS-00123 PLS-00123: program too large (string)
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.
Action The best solution is to modularize the program by defining subprograms, which can be stored in an Oracle database. Another solution is to break the program into two sub-blocks. Have the first block INSERT any data the second block needs into a temporary database table. Then, have the second block SELECT the data from the table.

 

PLS-00124 PLS-00124: name of exception expected for first arg in exception_init pragma
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.
Action Replace the first argument with the name of a legally declared exception.

 

PLS-00125 PLS-00125: type name expected
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.
Action Supply the type name

 

PLS-00126 PLS-00126: selector ALL is not allowed
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.
Action Remove the ALL shortcut from the SQL statement.

 

PLS-00127 PLS-00127: Pragma string is not a supported pragma
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.
Action Check the spelling of the pragma name, and make sure the proper syntax was used.

 

PLS-00128 PLS-00128: Illegal number of arguments for pragma string
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).
Action Supply the missing argument, or correct the faulty syntax.

 

PLS-00129 PLS-00129: Pragma INTERFACE only supports C as its first argument
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).
Action Check the spelling of the first parameter, which should be C, and make sure the proper syntax was used.

 

PLS-00130 PLS-00130: Pragma string expects 1st argument to be a procedure/function/package/cursor
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).
Action Check the spelling of the first parameter, and make sure the proper syntax was used.

 

PLS-00131 PLS-00131: Pragma string expects 2nd argument to be a procedure
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).
Action Check the spelling of the second parameter, and make sure the proper syntax was used.

 

PLS-00132 PLS-00132: Pragma RESTRICT_REFERENCES does not support string
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)
Action Check the spelling of all the parameters, and make sure the proper syntax was used.

 

PLS-00133 PLS-00133: Pragma string expects 1st argument to be an identifier or string-literal
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).
Action Check the spelling of the first parameter, and make sure the proper syntax was used.

 

PLS-00134 PLS-00134: Pragma string expects 2nd argument to be an identifier or string-literal
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).
Action Check the spelling of the second parameter, and make sure the proper syntax was used.

 

PLS-00135 PLS-00135: Pragma string expects 3rd argument to be an identifier, string or numeric literal
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).
Action Check the coding of the fourth parameter, and make sure the proper syntax was used.

 

PLS-00138 PLS-00138: Precision for a binary type must be one of 8, 16, or 32
Cause Invalid precision was specified for a signed or unsigned binary type.
Action Specify precision as one of 8, 16, or 32.

 

PLS-00139 PLS-00139: duplicate external NAME specification in subprogram expression
Cause The subprogram was found to have two external NAME specifications.
Action Remove one of the external NAME specifications.

 

PLS-00140 PLS-00140: duplicate external LIBRARY specification in subprogram expression
Cause The subprogram was found to have two external LIBRARY specifications.
Action Remove one of the external LIBRARY specifications.

 

PLS-00141 PLS-00141: duplicate external PARAMETER STYLE specification in subprogram expression
Cause The subprogram was found to have two external PARAMETER STYLE specifications.
Action Remove one of the external PARAMETER STYLE specifications.

 

PLS-00142 PLS-00142: duplicate external PARAMETER list specification in subprogram expression
Cause The subprogram was found to have two external PARAMETER STYLE specifications.
Action Remove one of the external PARAMETER STYLE specifications.

 

PLS-00143 PLS-00143: duplicate external LANGUAGE specification in subprogram expression
Cause The subprogram was found to have two external LANGUAGE specifications.
Action Remove one of the external LANGUAGE specifications.

 

PLS-00144 PLS-00144: duplicate external CALLING STANDARD specification in subprogram expression
Cause The subprogram was found to have two external CALLING STANDARD specifications.
Action Remove one of the external CALLING STANDARD specifications.

 

PLS-00145 PLS-00145: duplicate external WITH CONTEXT specification in subprogram expression
Cause The subprogram was found to have two external WITH CONTEXT specifications.
Action Remove one of the external WITH CONTEXT specifications.

 

PLS-00146 PLS-00146: duplicate external TRUSTED/UNTRUSTED specification in subprogram expression
Cause The subprogram was found to have two external TRUSTED/UNTRUSTED specifications.
Action Remove one of the external external TRUSTED/UNTRUSTED specifications.

 

PLS-00147 PLS-00147: LIBRARY file specification string is empty
Cause A zero-length string was found for the LIBRARY file specification.
Action Specify a non-zero length string for the LIBRARY file specification.

 

PLS-00148 PLS-00148: Only 1 pragma of this type is allowed per subprogram
Cause The subprogram was found to have two PRAGMA RESTRICT_REFERENCES.
Action Remove one of the PRAGMA RESTRICT_REFERENCES.

 

PLS-00150 PLS-00150: found: string but expected : INTEGER
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.
Action none

 

PLS-00151 PLS-00151: Expression or Variable is an illegal type to PLS/QL: string
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.
Action none

 

PLS-00152 PLS-00152: POINTER type may only reference an object 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.
Action none

 

PLS-00153 PLS-00153: A string type may only be used as an object type attribute.
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.
Action none

 

PLS-00154 PLS-00154: An object type may have only 1 MAP or 1 ORDER method.
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.
Action none

 

PLS-00155 PLS-00155: Only a function may be a MAP, ORDER or CONSTRUCTOR method.
Cause A procedure was declared as a MAP, ORDER or CONSTRUCTOR method. Only functions can be MAP, ORDER or CONSTRUCTOR methods.
Action none

 

PLS-00156 PLS-00156: Null constraints not supported for object attributes.
Cause A null constraint was specified for an attribute in an object. This is not supported.
Action Remove the constraint.

 

PLS-00157 PLS-00157: AUTHID only allowed on schema-level programs
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.
Action Remove the clause

 

PLS-00160 PLS-00160: AUTHID must specify CURRENT_USER or DEFINER
Cause The only two allowed options for AUTHID are CURRENT_USER and DEFINER.
Action Fix the AUTHID clause to specify CURRENT_USER or DEFINER

 

PLS-00161 PLS-00161: Pragma string expects 3rd argument to be an identifier or a string literal
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).
Action Check the spelling of the third parameter, and make sure the proper syntax was used.

 

PLS-00162 PLS-00162: Pragma string expects 4th argument to be a positive integer literal
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).
Action Check the spelling of the fourth parameter, and make sure the proper syntax was used.

 

PLS-00164 PLS-00164: cursor subqueries are not supported in this release
Cause This feature is not yet implemented.
Action none

 

PLS-00165 PLS-00165: call statement is not supported in PL/SQL
Cause A CALL statement was found in PL/SQL source.
Action Use an ordinary PL/SQL function or procedure call.

 

PLS-00166 PLS-00166: bad format for date, time or timestamp literal
Cause The contents of the date, time or timestamp literal did not match the expected format "yyyy-mm-dd hh24:mi:ssxfftzh:tzm".
Action Use a correctly-formatted datetime literal.

 

PLS-00167 PLS-00167: keyword BULK is used in a wrong context
Cause keyword BULK is used illegally. For example, BULK is used without INTO clause
Action remove the keyword BULK.

 

PLS-00168 PLS-00168: duplicate modifier specification "string"
Cause A method or object type modifier was specified more than once.
Action Remove all but one occurence of the duplicate modifier.

 

PLS-00169 PLS-00169: modifier "string" conflicts with prior "string" specification
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.
Action Remove one of the conflicting modifiers.

 

PLS-00170 PLS-00170: the SQL statement in an OPEN statement or FOR loop must be a SELECT
Cause An OPEN cursor statement or cursor FOR loop can only invoke a SELECT statement, not an UPDATE, INSERT or DELETE.
Action Use only SELECT statements in OPEN or cursor FOR loops

 

PLS-00171 PLS-00171: duplicate dedicated AGENT specification in subprogram expression
Cause The subprogram was found to have two dedicated AGENT specifications.
Action Remove one of the dedicated AGENT specifications.

 

PLS-00172 PLS-00172: string literal too long
Cause The string literal was longer than 32767 bytes.
Action Use a string literal of at most 32767 bytes.

 

PLS-00173 PLS-00173: SPACE, TAB or RETURN are disallowed as alternative quote delimiters
Cause SPACE, TAB or RETURN was used as alternative quote delimiter.
Action Use a character other than SPACE, TAB or RETURN as the alternative quote delimiter.

 

PLS-00174 PLS-00174: a static boolean expression must be used
Cause The expression contained a syntax or semantic error, or it did not have a boolean type or its evaluation raised an exception.
Action Write correct static boolean expression.

 

PLS-00176 PLS-00176: unexpected preprocessor token "$string"
Cause A preprocessor token was used inappropriately.
Action Remove the preprocessor token that is inappropriately used.

 

PLS-00177 PLS-00177: "$string" preprocessor directive does not end properly
Cause A preprocessor directive was not ended properly.
Action Use $end to end the preprocessor directive properly.

 

PLS-00178 PLS-00178: a static character expression must be used
Cause The expression contained a syntax or semantic error, or it did not have a character type or its evaluation raised an exception.
Action Write correct static character expression.

 

PLS-00179 PLS-00179: $ERROR: string
Cause $ERROR directive was used. This is an expected error message.
Action NA

 

PLS-00180 PLS-00180: preprocessor directives are not supported in this context
Cause A preprocessor directive was used in a compilation unit for which conditional compilation is not supported.
Action Do not use any preprocessor directives in this compilation unit.

 

PLS-00181 PLS-00181: unsupported preprocessor directive "string"
Cause An unsupported preprocessor directive was used.
Action Use a supported preprocessor directive.

 

PLS-00201 PLS-00201: identifier "string" must be declared
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.
Action
1) Check your spelling and declaration of the referenced name.
2) Verify that the declaration for the referenced item is placed correctly in the block structure.
3) If the referenced item is indeed declared but you don"t have privileges to refer to that item, for security reasons, you will be notified only that the item is not declared.
4) If the referenced item is indeed declared and you believe that you have privileges to refer to that item, check the privileges; if the privileges were granted only via a role, then this is expected and documented behavior. Stored objects (packages, procedures, functions, triggers, views) run in the security domain of the object owner with no roles enabled except PUBLIC. Again, you will be notified only that the item was not declared.

 

PLS-00202 PLS-00202: type "string" must be declared
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.
Action Check the spelling and declaration of the type specifier. Also confirm that the declaration is placed correctly in the block structure.

 

PLS-00203 PLS-00203: function DECODE must be called with at least 3 non-boolean arguments
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.
Action Call DECODE with three or more arguments

 

PLS-00204 PLS-00204: function or pseudo-column "string" may be used inside a SQL statement only
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.
Action Remove the pseudocolumn reference or function call from the procedural statement. Or, replace the procedural statement with a SELECT INTO statement; for example, replace bonus := DECODE(rating, 1, 5000, 2, 2500, ...); with the following statement: SELECT DECODE(rating, 1, 5000, 2, 2500, ...) INTO bonus FROM dual;

 

PLS-00205 PLS-00205: Aggregate not allowed here
Cause An aggregate, that is, a parenthesized list of values such as (7788, "SCOTT", 20), was found in an inappropriate context.
Action Remove or relocate the aggregate.

 

PLS-00206 PLS-00206: %%TYPE must be applied to a variable, column, field or attribute, not to "string"
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.
Action Declare an object of the appropriate class or define the datatype in another way (for example, use %ROWTYPE).

 

PLS-00207 PLS-00207: identifier "string", applied to implicit cursor SQL, is not a legal cursor attribute
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.
Action Check the spelling of the cursor attribute name. Make sure the attribute is one of these: %NOTFOUND, %FOUND, %ROWCOUNT, %ISOPEN.

 

PLS-00208 PLS-00208: identifier "string" is not a legal cursor attribute
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.
Action Check the spelling of the cursor attribute name. Make sure the attribute is one of these: %NOTFOUND, %FOUND, %ROWCOUNT, %ISOPEN.

 

PLS-00209 PLS-00209: table "string" is not in FROM clause
Cause In a query, a table referenced by the select list is not named in the FROM clause.
Action Check the spelling of the table names, make sure each column in the select list refers to a table in the FROM clause, then re-execute the query.

 

PLS-00210 PLS-00210: an OTHERS clause is required in this CASE statement
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).
Action none

 

PLS-00211 PLS-00211: CASE labels or ranges must not be duplicated in different WHEN clauses
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.
Action none

 

PLS-00212 PLS-00212: could not obtain enough memory to compile CASE statement
Cause The CASE statement is too big. The compiler did not have enough storage to process it.
Action none

 

PLS-00213 PLS-00213: package STANDARD not accessible
Cause The PL/SQL compiler could not find package STANDARD in the current Oracle database. To compile a program, PL/SQL needs package STANDARD.
Action Make sure that package STANDARD is available in the current Oracle database, then retry the operation.

 

PLS-00214 PLS-00214: BEGIN...END block nesting is too deep
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.
Action Reorganize the block structure to avoid nesting at too deep a level. For example, move the lowest-level sub-block to a higher level.

 

PLS-00215 PLS-00215: String length constraints must be in range (1 .. 32767)
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
Action Change the length constraint, making sure that it lies in the range 1 .. 32767.

 

PLS-
00216
PLS-00216: NUMBER precision constraint must be in range (1 .. 38)
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.
Action Change the illegal NUMBER precision constraint, making sure that it lies in the range 1 .. 38.

 

PLS-00217 PLS-00217: NUMBER scale constraint must be in range (-84 .. 127)
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.
Action Change the illegal NUMBER scale constraint, making sure that it lies in the range -84 .. 127.

 

PLS-00218 PLS-00218: a variable declared NOT NULL must have an initialization assignment
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.
Action Add an initialization clause to the variable declaration. If the initilization is too complicated for the syntax, one can add a function call (in a later release).

 

PLS-00219 PLS-00219: label "string" reference is out of scope
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.
Action Check the spelling and declaration of the variable name. Also confirm that the declaration is placed correctly in the block structure.

 

PLS-00220 PLS-00220: simple name required in this context
Cause A qualified name such as A.B or A.B.C is not permitted here.
Action Use a simple name such as A instead.

 

PLS-00221 PLS-00221: "string" is not a procedure or is undefined
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).
Action Check the spelling and declaration of the identifier. Also confirm that the declaration is placed correctly in the block structure.

 

PLS-00222 PLS-00222: no function with name "string" exists in this scope
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).
Action Check the spelling and declaration of the identifier. Also confirm that the declaration is placed correctly in the block structure.

 

PLS-00223 PLS-00223: paramaterless procedure "string" used as function
Cause An identifier being referenced as a parameterless function actually represents a procedure.
Action Check the spelling and declaration of the identifier. Also confirm that the declaration is placed correctly in the block structure. If necessary, change the declaration of the identifier or change the reference so that it does not require a return value.

 

PLS-00224 PLS-00224: object "string" must be of type function or array to be used this way
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.
Action Check the spelling and declaration of the identifier. Also confirm that the declaration is placed correctly in the block structure.

 

PLS-00225 PLS-00225: subprogram or cursor "string" reference is out of scope
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;
Action a) if the intention was to refer to a local variable of a non-enclosing function, this is not allowed; remove the reference b) if this is a parameterless function, and the the intention was to access a field of the result of a call to this function, then use empty parentheses in the call.

 

PLS-00226 PLS-00226: package "string" used as variable reference
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 ...
Action Correct the spelling of the variable or function name or use dot notation to reference the packaged variable or function.

 

PLS-00227 PLS-00227: subprogram "in" formal string is not yet denotable
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.
Action Remove the illegal formal parameter reference.

 

PLS-00228 PLS-00228: Illegal declaration of variable of type LONG
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).
Action Remove the offending variable definition

 

PLS-00229 PLS-00229: Attribute expression within SQL expression
Cause An attribute expression, such as SQL%NOTFOUND, was used in a SQL statement, but attribute expressions are allowed only in procedural statements.
Action To workaround this limitation, assign the value of the attribute expression to a variable, then use the variable in the SQL statement. For example, replace the statement INSERT INTO audits VALUES (c1%ROWCOUNT, ...); with the following statements: row_count := c1%ROWCOUNT; INSERT INTO audits VALUES (row_count, ...);

 

PLS-00230 PLS-00230: OUT and IN OUT formal parameters may not have default expressions
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.
Action Remove the illegal default expression.

 

PLS-00231 PLS-00231: function "string" may not be used in SQL
Cause A proscribed function was used in a SQL statement. Certain functions such as SQLCODE and SQLERRM can be used only in procedural statements.
Action Remove the function call from the SQL statement. Or, replace the function call with a local variable. For example, the following statement is illegal: INSERT INTO errors VALUES (SQLCODE, SQLERRM); However, you can assign the values of SQLCODE and SQLERRM to local variables, then use the variables in the SQL statement, as follows: err_num := SQLCODE; err_msg := SQLERRM; INSERT INTO errors VALUES (err_num, err_msg);

 

PLS-00232 PLS-00232: nested packages not permitted
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.
Action Move the package declaration outside the enclosing package.

 

PLS-00233 PLS-00233: function name used as an exception name in when clause
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.
Action Check the spelling of the identifier in the WHEN clause, then replace the function call with an exception name.

 

PLS-00234 PLS-00234: PARAMETER STYLE SQL may not be specified with a PARAMATERS list
Cause A subprogram cannot specify both PARAMETER STYLE SQL and an explicit PARAMETERS list. Use PARAMETER STYLE GENERAL to supply default PARAMETERS list types.
Action Change the subprogram specification.

 

PLS-00235 PLS-00235: the external type is not appropriate for the parameter
Cause An unsuccessful attempt was made to convert a parameter to the specified external parameter type.
Action Specify a different external type or parameter type.

 

PLS-00236 PLS-00236: Invalid external type specification for string.
Cause The external type specified is not valid for one of the following: INDICATOR, LENGTH, MAXLEN, TDO, DURATION, CHARSETID, or CHARSETFORM.
Action Check the manual and specify an appropriate external type.

 

PLS-00237 PLS-00237: invalid BY VALUE indicator or length specification
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.
Action Remove the BY VALUE specification or change it to IN mode.

 

PLS-00238 PLS-00238: external parameter name string not found in formal parameter list
Cause An external parameter name was specified that does not match one in the formal parameter list.
Action Correct the external parameter name.

 

PLS-00239 PLS-00239: invalid external type specification for SQLCODE
Cause An inappropriate external parameter type was specified for the SQLCODE parameter.
Action Correct the SQLCODE parameter specification.

 

 

Haut de Page www.dba-ora.fr

Partager cette page

Repost 0
Published by