GCP: manejo de excepciones en BigQuery

 

El manejo de excepciones es un mecanismo para identificar, tratar y recuperar el flujo normal de un programa en ejecución. El lenguaje de BigQuery nos permite gestionar los errores cuando estos ocurren  en nuestras consultas SQL. Miremos unos ejemplos.

El siguiente bloque de BigQuery tratará de ejecutar una consulta a una tabla que no existe (tabla_no_existente). El sub-bloque tiene un manejo de excepción de tipo ``ERROR``.

DECLARE error STRING;
BEGIN
  BEGIN
     -- Primera consulta, fallará.
     SELECT * FROM mydataset.tabla_no_existente;
  EXCEPTION WHEN ERROR THEN
      SET error = 'Ha ocurrido una excepcion.';
      RAISE; -- Termina la ejecución de todo el bloque. La segunda consulta no se realizará.
   END;

   -- Segunda consulta.
   SELECT * FROM mydataset.tabla_existente LIMIT 1;
END;

Si queremos que la segunda consulta se ejecute aún si ocurre un error en la primera consulta, entonces tan solo quitamos la instrucción ``RAISE``, la cual se utiliza para generar explícitamente un error o reactivar una excepción existente.

Tendríamos lo siguiente:

DECLARE error STRING;
BEGIN
  BEGIN
     -- Primera consulta, fallará.
     SELECT * FROM mydataset.tabla_no_existente;
  EXCEPTION WHEN ERROR THEN
      SET error = 'Ha ocurrido una excepcion.';
   END;

   -- Segunda consulta. Se ejecuta aunque la primera haya fallado.
   SELECT * FROM mydataset.tabla_existente LIMIT 1;
END;

La primera consulta fallará, pero no se terminará la ejecución del bloque completo. Se ejecutará la segunda consulta.

¿Cómo obtener información detallada del error ocurrido?

Crearemos un Stored Procedure que nos permitirá mostrar a detalle el error en la ejecución de una consulta SQL en BigQuery.

CREATE OR REPLACE PROCEDURE `mydataset.exec_sp_error`(OUT error_flag STRING)
BEGIN
   -- Esta consulta fallará.
   SELECT usuario,* FROM mydataset.tabla_no_existente;

  EXCEPTION WHEN ERROR THEN
   SET error_flag = "Error: ";
   SET error_flag = concat(salida, @@error.message);
   SET error_flag = concat(salida, ". Causa: "); 
   SET error_flag = concat(salida, @@error.statement_text);  
END;

Invocamos el Stored Procedure y consultamos la variable ``error_flag``:

DECLARE error_flag STRING;
-- Invocamos el Stored Procedure
CALL`mydataset.exec_sp_error`(error_flag);
-- Mostrará el error a detalle
SELECT error_flag;

En lenguajes de programación como Java, C++ y C# se puede hacer algo como esto:

try{
   int divide = 1/0;
}catch(ArithmeticException ex){
   System.err.printf("%s\n", ex.getCause());
   System.err.printf("%s\n", ex.getMessage());
   ex.printStackTrace();
}

Lo cual disparará una excepción de tipo ``ArithmeticException``, pues no podemos dividir un número por cero.

En BigQuery el código equivalente sería:

BEGIN
  SELECT 1/0; -- División por cero. 
EXCEPTION WHEN ERROR THEN
  SELECT @@error.message AS error_message;
  SELECT @@error.stack_trace AS stack_trace;
  SELECT @@error.statement_text AS text_error;
END;

Cuando se lance la excepción se mostrará los errores en la consola de BigQuery.

Continuaremos sobre esta serie de BigQuery más adelante.

Enlaces:

https://codemonkeyjunior.blogspot.com/2024/11/stored-procedures-oracle-plsql-gcp.html
https://cloud.google.com/bigquery/docs/error-messages

Stored procedures Oracle PL/SQL / GCP BigQuery

Haciendo un poco de memoria, recordaremos lo que es un Stored Procedure.

Un Stored Procedure (procedimiento almacenado) es:

• Un subprograma que ejecuta una acción específica.
• No devuelve valor alguno (pero mediante un mecanismo podemos recuperar valores).
• Posee un nombre y puede o no tener parámetros y un bloque donde se efectuarán las acciones a realizar.
• Se puede llamar desde otros Stored Procedures y/o consultas SQL.

Si usamos Oracle, está será será su sintaxis:

CREATE {OR REPLACE} PROCEDURE nombre_proc( param1 [IN | OUT | IN OUT] tipo,... )
IS
  -- Declaración de variables locales
  BEGIN
  -- Instrucciones de ejecución
  [EXCEPTION]
  -- Instrucciones de excepción
END;

En BigQuery, sería de esta forma:

CREATE PROCEDURE dataset_name.procedure_name(OUT param1 TYPE, ...)
BEGIN
-- statements here
  [EXCEPTION]
  -- statements here
END

La forma de invocar un Stored Procedure en Oracle:

CALL miprocedimiento();

En BigQuery:

CALL mydataset.miprocedimiento();

Lenguaje procedimental

Tanto GCP BigQuery como Oracle PL/SQL poseen sus propias peculiaridades. Empecemos con los bloques.

En PL/SQL:

DECLARE
BEGIN
   dbms_output.put_line('Hola, mundo');
END;
/

En BigQuery:

BEGIN
   SELECT FORMAT('Hola, mundo');
END;

También podemos hacer esto:

DECLARE saludo STRING DEFAULT 'Hola, mundo';
SELECT FORMAT(saludo);

Para declarar variables en PL/SQL:

DECLARE 
   entero integer := 10;
   numero NUMBER(3):= 123;
   nombre VARCHAR2(45);
   flotante real;
   tiempo_salida TIMESTAMP(3):= '23-JUL-2024 07:22:53.175';
   verdadero BOOLEAN:= FALSE;
   fecha DATE;
   ...
BEGIN
 -- SENTENCIAS
END;
/
     
   

En BigQuery:

DECLARE nombre STRING DEFAULT 'MARIA';
DECLARE fecha DATE;
DECLARE verdadero BOOL DEFAULT TRUE;
DECLARE numero INT64;
DECLARE otro_num NUMERIC DEFAULT 12.0;

SET numero = 9;
SET fecha = '2024-09-12';

...    
   

Es muy parecida la forma en que se declaran las variables.

Al ser lenguajes procedimentales tendrán:

1. Sentencias Top-Down o de arriba hacia abajo. 
2. Sentencias iterativas o repetitivas. 
3. Sentencias selectivas o condicionales.

Sentencias Top-Down

Sentencias de arriba hacia abajo. No hay mucha ciencia e ello. Comencemos con PL/SQL:

DECLARE
-- Declaramos las variables
numero INTEGER;
verdadero BOOLEAN;
fecha DATE;
presente NUMBER;

BEGIN
-- Seteamos sus valores
numero := 33;
verdadero := FALSE;
fecha := TO_DATE('2024/07/09', 'yyyy/mm/dd');
presente := 2300.23;


--
END;
/

En BigQuery:

BEGIN
DECLARE numero INT64;
DECLARE verdadero BOOL;
DECLARE fecha DATE;
DECLARE presente NUMERIC;

-- Seteamos sus valores
SET numero = 33;
SET verdadero = FALSE;
SET fecha = FORMAT_DATE("%Y-%d-%m",'2024/07/09');
SET presente = 2300.23;


--
END;

Sentencias iterativas o repetitivas

Bucle FOR en PL/SQL

FOR contador IN 1..20
LOOP
   contador := contador + 1;
END LOOP;

Bucle WHILE en PL/SQL

WHILE contador <= 100
LOOP
   contador := contador + 1;
END LOOP;

Bucle FOR en BigQuery

DECLARE vector_a ARRAY<STRING>;
SET vector_a = ['_01', '_02', '_03'];

FOR loop_variable_name IN (SELECT * FROM UNNEST(vector_a))
DO
  -- Hacer algo aquí;
END FOR;

Bucle WHILE en BigQuery

declare cont int64 default 0;
set TAM = (select count(*) from `project.dataset.tabla1`);
set cont = 1;

while cont <= TAM do
   -- 
   SET cont = cont + 1;
end while;

Solo son algunas sentencias repetitivas. Ambos incluyen otras como: LOOP.

Sentencias selectivas o condicionales

IF en PL/SQL

DECLARE 
  numero INTEGER;
  titulo VARCHAR2(5):="ABCD";

BEGIN
  numero:=33;
IF numero = 33 THEN
   SELECT "Hola, "||numero FROM dual;
END IF;

IF LENGTH(titulo) = 5 THEN
   SELECT 'La cadena tiene una longitud de 5';
ELSE 
   SELECT 'La cadena tiene una longitud de '||LENGTH(titulo);
END IF;

END;
/

IF en BigQuery

DECLARE numero INT64;
DECLARE titulo DEFAULT 'ABCD';
SET numero = 33;

IF numero = 33 THEN
   SELECT FORMAT('Hola, ', CAST(numero AS STRING));
END IF;

IF LENGTH(titulo) = 5 THEN
   SELECT 'La cadena tiene una longitud de 5';
ELSE 
   SELECT 'La cadena tiene una longitud de '||LENGTH(titulo);
END IF;

Solo mostramos algunas sentencias. Si quieres ver sentencias condicionales en BigQuery, puedes echar un vistazo en este link:

https://codemonkeyjunior.blogspot.com/2024/11/gcp-funciones-condicionales-en-bigquery.html

Continuaremos con este tema en siguientes posts.

Enlaces:

https://elbauldelprogramador.com/plsql-procedimientos-y-funciones/
https://docs.oracle.com/cd/B28359_01/appdev.111/b28843/tdddg_procedures.htm

PL/SQL: creando Stored Procedures (1era parte)

PL/SQL es un lenguaje de programación procedimental diseñado para operar en entornos Oracle.

Con este lenguaje podemos hacer:

• Automatizar tareas complejas dentro de la base de datos mediante procedimientos y funciones.
• Implementar reglas de negocio complejas con triggers y validaciones. 
• Gestionar transacciones y manejar errores de manera robusta. 
• Manipular conjuntos de datos utilizando cursores. 
• Integrar lógica de negocios en aplicaciones que interactúan con bases de datos Oracle.

En esta ocasión veremos cómo crear Stored Procedures o procedimientos almacenados. Los cuales son procedimiento que pueden o no devolver algún valor (contrario a las funciones que siempre devuelven algún valor). Estos podrán, una vez que sean creado, ser invocados en tus scripts.

La sintaxis para crear un Stored Procedure es la siguiente:

-- Sintaxis para crear un Stored Procedure 
CREATE [OR REPLACE] PROCEDURE procedure_name
    [ (parameter [,parameter]) ]

IS
    [declaration_section]

BEGIN
    executable_section

[EXCEPTION
    exception_section]

END [procedure_name];

Para su invocación debemos anteponer la palabra ``CALL`` seguido del nombre.

CALL miprocedimiento();
CALL miprocedimiento(arg1, arg2, argN);

En un anterior post vimos cómo crear bloques PL/SQL. Un Stored procedure contiene bloques que harán determinada tarea que nosotros definamos.

BEGIN
  DBMS_OUTPUT.PUT_LINE('Hola desde PL/SQL');
END;

Ejemplo 1. Crear un Stored procedure para mandar un mensaje a pantalla.

hola.sql

CREATE OR REPLACE PROCEDURE hola 
IS 
  nombre VARCHAR2(6):='Thomas';
BEGIN 
  IF nombre IS NOT NULL THEN 
    dbms_output.put_line('Hola, '||nombre);
  END IF;
END;
/

Lo invocamos de está forma:

SET VERIFY OFF;
SET SERVEROUTPUT ON;

-- Invocar Stored procedure
CALL hola;

Ejemplo 2. Crear un Stored Procedure para ver la versión de Oracle instalada.

mi_proc.sql

CREATE OR REPLACE PROCEDURE mi_proc
    IS
    version_inst VARCHAR(200);
    consulta VARCHAR(200):='SELECT BANNER FROM v$version';    
BEGIN
    dbms_output.put_line('Version instalada: ');
    -- Ejecutamos consulta
    EXECUTE IMMEDIATE consulta INTO version_inst;
    dbms_output.put_line(version_inst);
END;
/

Lo invocamos:

SET VERIFY OFF;
SET SERVEROUTPUT ON;

CALL mi_proc;

Enlaces:

https://codemonkeyjunior.blogspot.com/2023/07/plsql-bloques.html
https://www.plsqltutorial.com/

GCP: Crear Stored Procedures y Funciones en BigQuery

En esta ocasión veremos cómo crear Stored Procedures y funciones en BigQuery. Un procedimiento almacenado es un conjunto de instrucciones que se pueden llamar desde otras consultas o desde otros procedimientos almacenados.

• Puede tomar argumentos de entrada y mostrar valores como resultados.
• Puede acceder a los datos o modificarlos en varios conjuntos de datos de varios usuarios.
• También puede contener una consulta de varias instrucciones.

Ejemplo. Crear un Stored Procedure que mande un simple mensaje de "Hola, mundo". En este caso también le pasamos un párametro de nombre (name).

CREATE OR REPLACE PROCEDURE `myproject.mydataset.decirHola`(name STRING)
BEGIN
  SELECT FORMAT("Hola, %s",name);
END;

Para invocarlo:

CALL`myproject.mydataset.decirHola`('Thomas Muller');

Ejemplo. Teniendo esta sentencia SQL que nos devuelve la definición de un Stored Procedure en BigQuery:

-- Obtener la definición de un Stored Procedure en BigQuery
SELECT 
  routine_catalog, 
  routine_schema, 
  routine_name, 
  routine_type, 
  routine_definition
FROM your_dataset.INFORMATION_SCHEMA.ROUTINES    
WHERE routine_name = 'nombre_stored_procedure';

Crear un Stored Procedure que nos devuelva cada uno de los campos.

CREATE OR REPLACE PROCEDURE `myproject.mydataset.getDetallesStored`(nameStored STRING)
BEGIN
  -- Ejecutar la consulta y retornar los resultados
  DECLARE routine_catalog STRING;
  DECLARE routine_schema STRING;
  DECLARE routine_name STRING;
  DECLARE routine_type STRING;
  DECLARE routine_definition STRING;

  SELECT
    routine_catalog,
    routine_schema,
    routine_name,
    routine_type,
    routine_definition
  INTO 
    routine_catalog,
    routine_schema,
    routine_name,
    routine_type,
    routine_definition
  FROM
    myproject.mydataset.INFORMATION_SCHEMA.ROUTINES
  WHERE
    routine_name = nameStored;

  -- Seleccionar los resultados para retornarlos
  SELECT
    routine_catalog,
    routine_schema,
    routine_name,
    routine_type,
    routine_definition;
END;

Hacemos el llamado:

CALL `myproject.mydataset.getDetallesStored`('decirHola');

El resultado de este llamado nos arrojará los detalles del Stored Procedure indicado.

¿Y las funciones?

Una función es similar a un Stored Procedure (Procedimiento Almacenado), pero devolverá un valor. Además cambia la manera en la que lo invocamos. Mientras que un Stored Procedure es invocado con CALL, a una función la invocaremos con SELECT.

Ejemplo. Crear una función para dividir dos números.

CREATE OR REPLACE FUNCTION `myproject.mydataset.getDiv`(
  x FLOAT64, y FLOAT64) RETURNS FLOAT64
AS (
  SELECT DIV(X, Y) AS RESULT;
);

Para usar la función:

SELECT `myproject.mydataset.getDiv`(3.4,5.2);

Para quienes han usado PL/pgSQL (PostgreSQL) o PL/SQL (Oracle) la sintaxis es muy similar, por no decir idéntica. Salvo por algunas excepciones.

En próximas entregas continuaremos con este tema.

Enlaces:

https://cloud.google.com/bigquery/docs/procedures?hl=es-419

Aprender Oracle SQL con LiveSQL

Si deseas aprender SQL o mejorar tus habilidades existe un sitio para hacerlo: https://livesql.oracle.com/

LiveSql es un sitio con tutoriales, ejemplos y editor que nos permite ejecutar sentencias SQL como:

• Crear tablas.
• Crear vistas.
• Consultar datos de las tablas.
• Crear bloques PL/SQL.
• Crear funciones y procedimientos PL/SQL.
• etc.

¿Qué es SQL?

Son las siglas de Structured Query Language. Un lenguaje especializado para la creación y manipulación de la información contenida en tablas de información perteneciente a una base de datos.

El SQL se divide en:

• DCL: Data Control Language (GRANT/REVOQUE).
• TCL: Transaction Control Language (COMMIT/ROLLBACK/SAVEPOINT).
• DDL: Data Definition Language(CREATE/ALTER/DROP/RENAME/TRUNCATE).
• DML:Data Manipulation Language(INSERT/SELECT/UPDATE/DELETE).

DCL, nos permitirá otorgar y revocar permisos a tablas, funciones y procedimientos y otros objetos.

TCL, nos permitirá el control de las transacciones.

DDL, nos permitirá el control de la definición de los objetos.

DML, nos permitirá la manipulación de la información contenida.

LiveSql está enfocado tanto a principiantes como experimentados en el conocimiento de SQL. No permite crear o borrar bases de datos. No las necesitas, con que puedas crear tablas y manipularlas te bastará, ya que trabajarás con la BD que provee el sitio.

Oracle posee, al igual que otros SGBD (Sistema Gestor de Bases de Datos) su propios tipos de datos como lo pueden ser:

VARCHAR
CHAR
FLOAT
NUMBER
DATE
LONG
BINARY_FLOAT
BINARY_DOUBLE
TIMESTAMP
CLOB
BLOB
...

El editor nos permitirá ejecutar cualquier sentencia SQL válida:

select to_char(sysdate, 'HH:MI:SS') as hora from dual;

HORA

03:13:05

Podremos ejecutar bloques PL/SQL:

DECLARE
BEGIN
   dbms_output.put_line('Fecha: '||sysdate);
END;
/

Fecha: 12-MAY-24

Más ejemplos en próximos posts.

Enlaces:

https://livesql.oracle.com/

Un programa en varios lenguajes

 

Esta ocasión veremos un ejemplo de programa escrito en varios lenguajes de programación como: Java, Erlang, Python, Powershell, Clojure y otros más.

Ejercicio: Un programa que determine si una cadena ("ABC") tiene una longitud distinta de cero. Si la longitud de cadena es distinta de cero, que imprima la cadena en pantalla. Si no cumple la condición deberá mandar el mensaje: "Cadena vacía".

En pseudo código sería algo como esto:

// Pseudo code language
prog longitud:{
     var cadena:String = "ABC";
     var longitud:Int = cadena.size;
     if longitud != 0 then
        disp "${cadena}"
     else
        disp "Cadena vacía"
}

Por temas de espacio algunos bloques de código son omitidos para no hacer más grande el código, usted disculpe.

En Powershell:

longitud.ps1

$cadena="ABC"

if($cadena.Length -ne 0){
   Write-Host $cadena  
}
else{
   Write-Host "Cadena vacia"
}

En Clojure:

longitud.clj

(ns longitud)

(def cadena "ABC")
(def longitud (count cadena))
(if (not= longitud 0)
   (println cadena)
   (println "Cadena vacia")
)

En Erlang:

longitud.erl

-module(longitud).
-author("Codemonkey Junior Blogspot").
-version("1.0.0").
-export([start/0]).

println(Cosa) -> io:format("~p~n", [Cosa]).

start()->
    Cadena="ABC",
    Longitud=string:length(Cadena),
    if 
     Longitud /= 0 ->
       println(Cadena);
    true ->
       println("Cadena vacia")
    end.

En OpenEdge ABL:

longitud.p

define var as char no-undo initial "ABC".

if length(cadena)<>0 then
   disp cadena.
else
   disp "Cadena vacia".

En Rust:

longitud.rs

let cadena:String = String::from("ABC");

if cadena.chars().count()!=0 {
   println!("{}",cadena)
}
else{
   println!("Cadena vacia")
}

En PL/SQL:

longitud.sql

SET SERVEROUTPUT ON
DECLARE
  cadena varchar2(3):='ABC';
  BEGIN
       IF LENGTH(cadena) != 0 THEN
          dbms_output.put_line(cadena);
       ELSE
          dbms_output.put_line('Cadena vacia');
       END IF;
  END;
/

En Elixir:

longitud.exs

cadena = "ABC"

if String.length(cadena) != 0 do
  IO.puts "#{cadena}"
else
  IO.puts "Cadena vacia"
end

En R:

longitud.r

cadena <- "ABC"

if(nchar(cadena) != 0) {
  sprintf("%s",cadena)
}else{
  print("Cadena vacia")
}

En DataStage BASIC:

longitud.dsx

Option Explicit

' Declaración de variables
Dim cadena As String

' Asignación de valor a la variable
cadena = "ABC"

' Verificación de la longitud de la cadena
If Len(cadena) <> 0 Then
    ' Imprimir la cadena si no está vacía
    Print cadena
Else
    ' Imprimir un mensaje si la cadena está vacía
    Print "Cadena vacia"
End If

En Ballerina:

longitud.bal

import ballerina/io;

public function main() {
    string cadena = "ABC";

    if (lengthof cadena != 0) {
        io:println(cadena);
    } else {
        io:println("Cadena vacia");
    }
}

En C:

longitud.c

#include <stdio.h>
#include <string.h>

int main() {
    char cadena[] = "ABC";

    if (strlen(cadena) != 0) {
        printf("%s\n", cadena);
    } else {
        printf("Cadena vacia\n");
    }

    return 0;
}

En C++:

longitud.cpp

#include <iostream>
#include <string>

int main() {
    std::string cadena = "ABC";

    if (!cadena.empty()) {
        std::cout << cadena << std::endl;
    } else {
        std::cout << "Cadena vacia" << std::endl;
    }

    return 0;
}

En Haskell:

longitud.hs

main :: IO ()
main = do
    let cadena = "ABC"
    if length cadena /= 0
        then putStrLn cadena
        else putStrLn "Cadena vacia"

En Prolog:

longitud.pl

cadena_valida('ABC') :- write('ABC').
cadena_valida('') :- write('Cadena vacia').

main :- cadena_valida('ABC').

En Python:

longitud.py

cadena="ABC"
if len(cadena) !=0:
   print(cadena) 
else:
   print("Cadena vacia")

Este post se irá actualizando... see you later !!

PL/SQL - Bloques

PL/SQL es un lenguaje de programación procedimental para manipular datos de una BD Oracle. Con este lenguaje podemos crear scripts para poder manipular información de tablas, ejecutar otros scripts, crear procedimientos que se activen ante un evento(triggers), que devuelvan valores (funciones) o que simplementen realicen una operación al invocar un procedimiento (stored procedures).

Si queremos saber la versión instalada podemos ejecutar esta sentencia:

-- Con una consulta 
SELECT * FROM v$version;

En PL/SQL podríamos ejecutar el siguiente bloque de código:

-- Con un bloque PL/SQL
SET SERVEROUTPUT ON;
DECLARE
    version_inst VARCHAR(200);
    consulta VARCHAR(200):='SELECT BANNER FROM v$version';
BEGIN
    -- Ejecutamos consulta
    EXECUTE IMMEDIATE consulta INTO version_inst;
    dbms_output.put_line('Version instalada: '||version_inst);
END;
/

Si queremos podríamos crear excepciones:

-- Con un bloque PL/SQL con manejo de excepción
SET SERVEROUTPUT ON;
DECLARE
   NULL_STRING EXCEPTION;
   PRAGMA 
   EXCEPTION_INIT(NULL_STRING, -06535);
   version_inst VARCHAR(200);
   consulta VARCHAR(200);
BEGIN
    -- Ejecutamos consulta
    EXECUTE IMMEDIATE consulta INTO version_inst;
    dbms_output.put_line('Version instalada: '||version_inst);
    EXCEPTION
        WHEN NULL_STRING THEN
           dbms_output.put_line('Error: No existe la tabla o la consulta es erronea o esta vacía');
END;
/

Como se puede ver, creamos una excepción (NULL_STRING) para verificar que la cadena de consulta es nula (vacía). Usamos PRAGMA la cual es una palabra reservada de Oracle para añadir directivas al compilador. Ésta le dice al compilador que se comporte de cierta manera, en este caso es una excepción (un error en el flujo del programa).

El pragma EXCEPTION_INIT asocia un nombre de excepción con un número de error de Oracle. Puede interceptar cualquier error ORA- y escribir un controlador específico para él en lugar de usar el controlador OTROS (OTHERS).

La sección de EXCEPTION WHEN se ejecuta cuando ocurre alguna excepción. Dependiendo de la programación se podrá (o no) cachar correctamente la excepción. Recordar que una excepción es una anomalía en el flujo de un programa, no necesariamente es un error grave. En caso de un error, el programa se terminará abruptamente.

Al final tendríamos algo como esto:

-- Con un bloque PL/SQL y verificando consulta
SET SERVEROUTPUT ON;
DECLARE
   NULL_STRING EXCEPTION;
   PRAGMA 
   EXCEPTION_INIT(NULL_STRING, -06535);
   version_inst VARCHAR(200);
   consulta VARCHAR(200):='SELECT BANNER FROM v$version';
BEGIN
    IF LENGTH(consulta) > 0 THEN
       -- Ejecutamos consulta
       EXECUTE IMMEDIATE consulta INTO version_inst;
       dbms_output.put_line('Version instalada: '||version_inst);
    END IF;
    EXCEPTION
        WHEN NULL_STRING THEN
           dbms_output.put_line('Error: No existe la tabla o la consulta es erronea o esta vacía');
END;
/

En próximos post veremos más ejemplos.

Enlaces:

https://livesql.oracle.com/
https://www.techonthenet.com/oracle
http://www.rebellionrider.com
https://docs.oracle.com
https://www.codifica.me/pragma/
https://elbauldelprogramador.com/plsql-excepciones/