Scala – Exception Handling | Types of Exception

If You are interested to learn about the Scala Collection

Scala’s exceptions work like exceptions in many other languages like Java. Instead of returning a value in the normal way, a method can terminate by throwing an exception. However, Scala doesn’t actually have checked exceptions.

When you want to handle exceptions, you use a try{…}catch{…} block like you would in Java except that the catch block uses matching to identify and handle the exceptions.

Exception-Handling Syntax

Exceptions are handled at the block, level, i.e., once if any exception occurs in any block then the control will come out of execution part of that block. The exception will then be handled at the exception handling part of that block. After handling the exception, it is not possible to resend control back to the execution section of that block.

The below syntax explains how to catch and handle the exception.

Exception Handling in PL/SQL
BEGIN
execution block;
.
.
EXCEPTION
WHEN ;exceptionl_name;
THEN
 Exception handling code for the “exception 1 _name’';
WHEN OTHERS
THEN
  Default exception handling code for all exceptions;
END;

Syntax Explanation:

  • In the above syntax, the exception-handling block contains series of WHEN condition to handle the exception.
  • Each WHEN condition is followed by the exception name which is expected to be raised at the run time.
  • When any exception is raised at runtime, then the PL/SQL engine will look in the exception handling part for that particular exception. It will start from the first ‘WHEN’ clause and, sequentially it will search.
  • If it found the exception handling for the exception which has been raised, then it will execute that particular handling code part.
  • If none of the ‘WHEN’ clause is present for the exception which has been raised, then PL/SQL engine will execute the ‘WHEN OTHERS’ part (if present). This is common for all the exception.
  • After executing the exception, part control will go out of the current block.
  • Only one exception part can be executed for a block at run-time. After executing it, the controller will skip the remaining exception handling part and will go out of the current block.

Note: WHEN OTHERS should always be at the last position of the sequence. The exception handling part present after WHEN OTHERS will never get executed as the control will exit from the block after executing the WHEN OTHERS.

Types of Exception

There are two types of Exceptions in Pl/SQL.

  1. Predefined Exceptions
  2. User-defined Exception

Predefined Exceptions

Oracle has predefined some common exception. These exceptions have a unique exception name and error number. These exceptions are already defined in the ‘STANDARD’ package in Oracle. In code, we can directly use these predefined exception name to handle them.

Below are the few predefined exceptions

ExceptionError CodeException Reason
ACCESS_INTO_NULLORA-06530Assign a value to the attributes of uninitialized objects
CASE_NOT_FOUNDORA-06592None of the ‘WHEN’ clause in CASE statement satisfied and no ‘ELSE’ clause is specified
COLLECTION_IS_NULLORA-06531Using collection methods (except EXISTS) or accessing collection attributes on a uninitialized collections
CURSOR_ALREADY_OPENORA-06511Trying to open a cursor which is already opened
DUP_VAL_ON_INDEXORA-00001Storing a duplicate value in a database column that is a constrained by unique index
INVALID_CURSORORA-01001Illegal cursor operations like closing an unopened cursor
INVALID_NUMBERORA-01722Conversion of character to a number failed due to invalid number character
NO_DATA_FOUNDORA-01403When ‘SELECT’ statement that contains INTO clause fetches no rows.
ROW_MISMATCHORA-06504When cursor variable data type is incompatible with the actual cursor return type
SUBSCRIPT_BEYOND_COUNTORA-06533Referring collection by an index number that is larger than the collection size
SUBSCRIPT_OUTSIDE_LIMITORA-06532Referring collection by an index number that is outside the legal range (eg: -1)
TOO_MANY_ROWSORA-01422When a ‘SELECT’ statement with INTO clause returns more than one row
VALUE_ERRORORA-06502Arithmetic or size constraint error (eg: assigning a value to a variable that is larger than the variable size)
ZERO_DIVIDEORA-01476Dividing a number by ‘0’

User-defined Exception

In Oracle, other than the above-predefined exceptions, the programmer can create their own exception and handle them. They can be created at a subprogram level in the declaration part. These exceptions are visible only in that subprogram. The exception that is defined in the package specification is public exception, and it is visible wherever the package is accessible.

Syntax: At subprogram level

DECLARE
exception_name; EXCEPTION; 
BEGIN
Execution block;
EXCEPTION
WHEN ;exception_name; THEN 
;Handler;
END;
  • In the above syntax, the variable ‘exception_name’ is defined as ‘EXCEPTION’ type.
  • This can be used as in a similar way as a predefined exception.

Syntax:At Package Specification level

CREATE PACKAGE ;package_name;
 IS
exception_name; EXCEPTION;
.
.
END;package_name;
  • In the above syntax, the variable ‘exception_name’ is defined as ‘EXCEPTION’ type in the package specification of <package_name>.
  • This can be used in the database wherever package ‘package_name’ can be called.

PL/SQL Raise Exception

All the predefined exceptions are raised implicitly whenever the error occurs. But the user-defined exceptions needs to be raised explicitly. This can be achieved using the keyword ‘RAISE’. This can be used in any of the ways mentioned below.

If ‘RAISE’ is used separately in the program, then it will propagate the already raised exception to the parent block. Only in exception block can be used as shown below.

Exception Handling in PL/SQL
CREATE [ PROCEDURE | FUNCTION ]
 AS
BEGIN
;Execution block\;
EXCEPTION
WHEN ;exception_name; THEN 
             Handler;
RAISE;
END;

Syntax Explanation:

  • In the above syntax, the keyword RAISE is used in the exception handling block.
  • Whenever program encounters exception “exception_name”, the exception is handled and will be completed normally
  • But the keyword ‘RAISE’ in the exception handling part will propagate this particular exception to the parent program.

Note: While raising the exception to the parent block the exception that is getting raised should also be visible at parent block, else oracle will throw an error.

  • We can use keyword ‘RAISE’ followed by the exception name to raise that particular user-defined/predefined exception. This can be used in both execution part and in exception handling part to raise the exception.
Exception Handling in PL/SQL
CREATE [ PROCEDURE | FUNCTION ] 
AS
BEGIN
Execution block;
RAISE;exception_name
EXCEPTION
WHEN &lt;exception_name&gt; THEN
Handler&gt;
END;

Syntax Explanation:

  • In the above syntax, the keyword RAISE is used in the execution part followed by exception “exception_name”.
  • This will raise this particular exception at the time of execution, and this needs to be handled or raised further.

Example 1: In this example, we are going to see

  • How to declare the exception
  • How to raise the declared exception and
  • How to propagate it to the main block
Exception Handling in PL/SQL
Exception Handling in PL/SQL
DECLARE
Sample_exception EXCEPTION;
PROCEDURE nested_block
IS
BEGIN
Dbms_output.put_line(‘Inside nested block’);
Dbms_output.put_line(‘Raising sample_exception from nested block’);
RAISE sample_exception;
EXCEPTION
WHEN sample_exception THEN 
Dbms_output.put_line (‘Exception captured in nested block. Raising to main block’);
RAISE,
END;
BEGIN
Dbms_output.put_line(‘Inside main block’);
Dbms_output.put_line(‘Calling nested block’);
Nested_block;
EXCEPTION
WHEN sample_exception THEN	
Dbms_output.put_line (‘Exception captured in main block');
END:
/

Code Explanation:

  • Code line 2: Declaring the variable ‘sample_exception’ as EXCEPTION type.
  • Code line 3: Declaring procedure nested_block.
  • Code line 6: Printing the statement “Inside nested block”.
  • Code line 7: Printing the statement “Raising sample_exception from nested block.”
  • Code line 8: Raising the exception using ‘RAISE sample_exception’.
  • Code line 10: Exception handler for exception sample_exception in the nested block.
  • Code line 11: Printing the statement ‘Exception captured in nested block. Raising to main block’.
  • Code line 12: Raising the exception to main block (propagating to the main block).
  • Code line 15: Printing the statement “Inside the main block”.
  • Code line 16: Printing the statement “Calling nested block”.
  • Code line 17: Calling nested_block procedure.
  • Code line 18: Exception
  • Code line 19: Exception handler for sample_exception in the main block.
  • Code line 20: Printing the statement “Exception captured in the main block.”

Important points to note in Exception

  • In function, an exception should always either return value or raise the exception further. else Oracle will throw ‘Function returned without a value’ error at run-time.
  • Transaction control statements can be given at exception handling block.
  • SQLERRM and SQLCODE are the in-built functions that will give the exception message and code.
  • If an exception is not handled then by default all the active transaction in that session will be rolled back.
  • RAISE_APPLICATION_ERROR (-<error_code>, <error_message>) can be used instead of RAISE to raise the error with user code and message. Error code should be greater than 20000 and prefixed with ‘-‘.

Throwing Exceptions

Throwing an exception looks the same as in Java. You create an exception object and then you throw it with the throw keyword as follows.

throw new Illegal Argument Exception

Catching Exceptions

Scala allows you to try/catch any exception in a single block and then perform pattern matching against it using case blocks. Try the following example program to handle exception.

Example

import java.io.FileReader
import java.io.FileNotFoundException
import java.io.IOException

object Demo {
   def main(args: Array[String]) {
      try {
         val f = new FileReader("input.txt")
      } catch {
         case ex: FileNotFoundException =;{
            println("Missing file exception")
         }
         
         case ex: IOException =; {
            println("IO Exception")
         }
      }
   }
}

Save the above program in Demo.scala. The following commands are used to compile and execute this program.

Command

\>scalac Demo.scala
\>scala Demo

Output

Missing file exception

The behavior of this try-catch expression is the same as in other languages with exceptions. The body is executed, and if it throws an exception, each catch clause is tried in turn.

The finally Clause

You can wrap an expression with a finally clause if you want to cause some code to execute no matter how the expression terminates. Try the following program.

Example

import java.io.FileReader
import java.io.FileNotFoundException
import java.io.IOException

object Demo {
   def main(args: Array[String]) {
      try {
         val f = new FileReader("input.txt")
      } catch {
         case ex: FileNotFoundException =; {
            println("Missing file exception")
         }
         
         case ex: IOException =; {
            println("IO Exception")
         }
      } finally {
         println("Exiting finally...")
      }
   }
}

Save the above program in Demo.scala. The following commands are used to compile and execute this program.

Command

\>scalac Demo.scala
\>scala Demo

Output

Missing file exception
Exiting finally...

Scala – Exception Handling | Types of Exception
Show Buttons
Hide Buttons