PL/SQL Variable Scope & Inner Outer Block: Nested Structure

By : Fiona Brown Fiona Brown
Hours Updated

⚡ Smart Summary

Nested blocks in PL/SQL place one block inside another, letting you separate complex logic and isolate exception handling. Understanding variable scope between the outer and inner blocks, and using block labels, keeps same-named variables unambiguous.

  • 🧱 Nested Block: A nested block is a PL/SQL block placed inside another block’s execution or exception section.
  • 🌳 Outer and Inner: One outer, or parent, block can contain many inner, or child, blocks, each a full PL/SQL block.
  • 👁️ Variable Scope: Outer-block variables declared before an inner block are visible inside it, but inner-block variables are not visible outside.
  • 🏷️ Block Labels: Labelling the outer block lets the inner block reference a same-named outer variable as label.variable_name.
  • 🛡️ Exception Isolation: Nesting lets each block handle its own exceptions, keeping error handling close to the code that raises it.
  • 🤖 AI Assistance: AI assistants such as GitHub Copilot draft labelled nested blocks and flag variable-scope conflicts.
Read More

PL/SQL variable scope across nested inner and outer blocks

What is Nested Blocks Oracle?

In PL/SQL, each block can be nested inside another block. Such a block is referred to as a nested block. Nested blocks are very common when you want to perform a certain process while keeping the code for that process in a separate container (block).

The nested block concept helps the programmer improve readability by separating complex logic into individual blocks, and it allows the exception for each block to be handled inside the main outer block.

Nested Block Structure

A block can be nested inside another block. It can be nested either in the execution part or in the exception handling part, and these blocks can also be labeled. One outer block can contain many inner blocks. Each inner block is itself a PL/SQL block, so all the properties and characteristics of the inner block are the same as those of the outer block. The parent block is the main block, and the child block is the nested block.

The image below gives a pictorial representation of the nested block structure, in which the parent block is the main block and the child block is the nested block.

Pictorial representation of a PL/SQL nested block with a parent outer block and a child inner block

Below is the syntax for the nested block. The screenshot below shows the nested block syntax with its labeled outer and inner blocks.

Nested block syntax showing labeled outer and inner blocks each with DECLARE, BEGIN, and EXCEPTION sections

Nested Block Syntax

<<outer_block>>
DECLARE
 <Declarative section> 
BEGIN
 <Execution part for outer block begins>

 <<inner block>>
 DECLARE
  <Declarative section>
 BEGIN
  <Execution part for inner block>.
 EXCEPTION 
  <Exception handling part>
 END;

 <Execution part for outer block begins> 
EXCEPTION 
<Exception handling part>
END;
  • The syntax above shows the nested block that contains a total of two blocks.
  • These blocks are labelled as ‘outer_block’ and ‘inner_block’.

Scopes in Nested Block: Variable Scope

In a nested block, you need to clearly understand the scope and visibility of each block before using them. Particularly in the inner block, elements from both the outer and the inner block are visible, so a proper understanding of this is necessary.

The points below summarize the scopes in nested blocks.

  • The elements declared in the outer block, and the value defined before the inner block definition, are visible inside the inner block.
  • The elements declared in the inner block are not visible in the outer block. They are visible only within the inner block.
  • The outer block and the inner block can have a variable with the same name.
  • In the case of variables with the same name, the inner block by default refers to the variable declared in the inner block only.
  • If the inner block wants to refer to the outer block variable that has the same name as the inner block variable, then the outer block must be LABELLED, and the outer block variable can be referred to as ‘<outer_block_label>.<variable_name>’.

The example below helps you understand more about these scopes.

RELATED ARTICLES

Example 1: In this example, we see the scope of variables in the inner and outer block. We also see how to refer to the variables using a block label.

The screenshot below shows Example 1, where the inner block refers to an outer block variable using the block label.

Example of variable scope in nested blocks referring to an outer block variable by its block label

<<OUTER_BLOCK>>
DECLARE
var1 VARCHAR2(30):='outer_block';
var2 VARCHAR2(30):='value before inner block';
BEGIN
<<INNER_BLOCK>>
DECLARE
var1 VARCHAR2(30):='inner_block';
BEGIN
dbms_output.put_line(var1);
dbms_output.put_line(OUTER_BLOCK.var1); 
dbms_output.put_line(var2);
END;
var2:='value after inner block';
END;
/

Code Explanation:

  • Code line 1: Labelling the outer block as “OUTER_BLOCK”.
  • Code line 3: Declaring a variable ‘var1’ as VARCHAR2 (30) with the initial value of “outer_block”.
  • Code line 4: Declaring a variable ‘var2’ as VARCHAR2 (30) with the initial value of “value before inner block”.
  • Code line 6: Labelling the inner block as “INNER_BLOCK”.
  • Code line 8: Declaring a variable ‘var1’ in the inner block as VARCHAR2 (30) with the initial value of “inner_block”.
  • Code line 10: Printing the value of ‘var1’. Since no label is mentioned, by default it takes the value from the inner block, hence printing the ‘inner_block’ message.
  • Code line 11: Printing the value of the outer block variable ‘var1’. Since the inner block has a variable with the same name, we refer to the outer block label. Thus it prints the ‘outer_block’ message.
  • Code line 12: Printing the value of the outer block variable ‘var2’. Since there is no variable with this name in the inner block, by default it takes the value from the outer block, hence printing the ‘value before inner block’ message.
  • The variable ‘var2’ in the outer block is assigned the value ‘value after inner block’. But this assignment happens after the definition of the inner block, so this value is not present inside the inner block.

Example 2: In this example, we find the difference between two numbers, one declared in the outer block and another in the inner block. Both have the same name. Let us see how the block label is useful in referring to these variables.

The screenshot below shows Example 2, which computes the difference between the outer and inner block variables of the same name.

Example computing the difference between outer and inner block variables of the same name using block labels

<<OUTER_BLOCK>>
DECLARE 
ln_val NUMBER :=5;
BEGIN
<<INNER_BLOCK>>
DECLARE 
ln_val NUMBER :=3;
BEGIN
dbms_output.put_line('The difference between outer block and inner block variable is:'||outer_block.ln_val-inner_block.ln_val);
END;
END;
/

Code Explanation:

  • Code line 1: Labelling the outer block as “OUTER_BLOCK”.
  • Code line 3: Declaring a variable ‘ln_val’ as NUMBER with the initial value of “5”.
  • Code line 5: Labelling the inner block as “INNER_BLOCK”.
  • Code line 7: Declaring a variable ‘ln_val’ in the inner block as NUMBER with the initial value of “3”.
  • Code line 9: Printing the difference in value of ‘ln_val’ from the outer and inner block. The “<block_name>.<variable_name>” format is used to refer to these variables to avoid conflicts due to the same variable name.

FAQs

A nested block is an anonymous block placed inside another block and runs inline where it appears. A subprogram (procedure or function) is a named, reusable unit that is stored separately and called by name, optionally with parameters.

Each block can have its own EXCEPTION section. An exception raised in the inner block is handled by that block first; if it is unhandled, it propagates to the enclosing outer block’s handler. This lets you isolate error handling per block.

PL/SQL does not impose a small fixed limit, so blocks can be nested many levels deep. In practice, deep nesting hurts readability, so most code keeps nesting to two or three levels and moves reusable logic into subprograms.

A block label, written as a name in double angle brackets before DECLARE, names a block. Labels let inner code qualify an outer variable as label.variable_name and can also serve as GOTO targets, making nested code easier to read and document.

Yes. A nested block can appear anywhere an executable statement is allowed, including inside a loop, an IF branch, or a procedure body. This lets you scope declarations and exception handling to just the part of the code that needs them.

Nesting is mainly a compile-time structuring tool and adds no meaningful runtime overhead by itself. It improves readability and error isolation. Excessive deep nesting mostly costs maintainability rather than raw speed.

Yes. GitHub Copilot drafts labelled outer and inner blocks, including DECLARE, BEGIN, and EXCEPTION sections, from a comment. Review the block labels and variable scope so same-named inner and outer variables resolve as intended.

AI assistants analyze nested blocks and flag shadowed variables, unqualified references, and out-of-scope access. This machine-learning review highlights places where an inner block silently uses the wrong same-named variable before the code runs.

Summarize this post with: