PL / SQL - Funzioni

In questo capitolo, discuteremo le funzioni in PL / SQL. Una funzione è uguale a una procedura tranne per il fatto che restituisce un valore. Pertanto, tutte le discussioni del capitolo precedente valgono anche per le funzioni.

Creazione di una funzione

Una funzione standalone viene creata utilizzando il CREATE FUNCTIONdichiarazione. La sintassi semplificata perCREATE OR REPLACE PROCEDURE l'affermazione è la seguente:

CREATE [OR REPLACE] FUNCTION function_name 
[(parameter_name [IN | OUT | IN OUT] type [, ...])] 
RETURN return_datatype 
{IS | AS} 
BEGIN 
   < function_body > 
END [function_name];

Dove,

nome-funzione specifica il nome della funzione.
L'opzione [OR REPLACE] consente la modifica di una funzione esistente.
L'elenco dei parametri facoltativi contiene nome, modalità e tipi di parametri. IN rappresenta il valore che verrà passato dall'esterno e OUT rappresenta il parametro che verrà utilizzato per restituire un valore al di fuori della procedura.
La funzione deve contenere un file return dichiarazione.
La clausola RETURN specifica il tipo di dati che si intende restituire dalla funzione.
function-body contiene la parte eseguibile.
La parola chiave AS viene utilizzata al posto della parola chiave IS per creare una funzione autonoma.

Esempio

L'esempio seguente illustra come creare e chiamare una funzione autonoma. Questa funzione restituisce il numero totale di CLIENTI nella tabella dei clienti.

Useremo la tabella CUSTOMERS, che avevamo creato nel capitolo Variabili PL / SQL -

Select * from customers; 
 
+----+----------+-----+-----------+----------+ 
| ID | NAME     | AGE | ADDRESS   | SALARY   | 
+----+----------+-----+-----------+----------+ 
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 | 
|  2 | Khilan   |  25 | Delhi     |  1500.00 | 
|  3 | kaushik  |  23 | Kota      |  2000.00 | 
|  4 | Chaitali |  25 | Mumbai    |  6500.00 | 
|  5 | Hardik   |  27 | Bhopal    |  8500.00 | 
|  6 | Komal    |  22 | MP        |  4500.00 | 
+----+----------+-----+-----------+----------+

CREATE OR REPLACE FUNCTION totalCustomers 
RETURN number IS 
   total number(2) := 0; 
BEGIN 
   SELECT count(*) into total 
   FROM customers; 
    
   RETURN total; 
END; 
/

Quando il codice sopra viene eseguito utilizzando il prompt SQL, produrrà il seguente risultato:

Function created.

Chiamare una funzione

Durante la creazione di una funzione, dai una definizione di ciò che la funzione deve fare. Per utilizzare una funzione, dovrai chiamare quella funzione per eseguire l'attività definita. Quando un programma chiama una funzione, il controllo del programma viene trasferito alla funzione chiamata.

Una funzione chiamata esegue l'attività definita e quando viene eseguita la sua istruzione return o quando il file last end statement viene raggiunto, riporta il controllo del programma al programma principale.

Per chiamare una funzione, è sufficiente passare i parametri richiesti insieme al nome della funzione e se la funzione restituisce un valore, è possibile memorizzare il valore restituito. Il programma seguente chiama la funzionetotalCustomers da un blocco anonimo -

DECLARE 
   c number(2); 
BEGIN 
   c := totalCustomers(); 
   dbms_output.put_line('Total no. of Customers: ' || c); 
END; 
/

Quando il codice precedente viene eseguito al prompt SQL, produce il seguente risultato:

Total no. of Customers: 6  

PL/SQL procedure successfully completed.

Esempio

L'esempio seguente mostra la dichiarazione, la definizione e il richiamo di una semplice funzione PL / SQL che calcola e restituisce il massimo di due valori.

DECLARE 
   a number; 
   b number; 
   c number; 
FUNCTION findMax(x IN number, y IN number)  
RETURN number 
IS 
    z number; 
BEGIN 
   IF x > y THEN 
      z:= x; 
   ELSE 
      Z:= y; 
   END IF;  
   RETURN z; 
END; 
BEGIN 
   a:= 23; 
   b:= 45;  
   c := findMax(a, b); 
   dbms_output.put_line(' Maximum of (23,45): ' || c); 
END; 
/

Quando il codice precedente viene eseguito al prompt SQL, produce il seguente risultato:

Maximum of (23,45): 45   

PL/SQL procedure successfully completed.

Funzioni ricorsive PL / SQL

Abbiamo visto che un programma o un sottoprogramma può chiamare un altro sottoprogramma. Quando un sottoprogramma chiama se stesso, viene indicato come una chiamata ricorsiva e il processo è noto comerecursion.

Per illustrare il concetto, calcoliamo il fattoriale di un numero. Il fattoriale di un numero n è definito come -

n! = n*(n-1)! 
   = n*(n-1)*(n-2)! 
      ... 
   = n*(n-1)*(n-2)*(n-3)... 1

Il seguente programma calcola il fattoriale di un dato numero chiamando se stesso ricorsivamente:

DECLARE 
   num number; 
   factorial number;  
   
FUNCTION fact(x number) 
RETURN number  
IS 
   f number; 
BEGIN 
   IF x=0 THEN 
      f := 1; 
   ELSE 
      f := x * fact(x-1); 
   END IF; 
RETURN f; 
END;  

BEGIN 
   num:= 6; 
   factorial := fact(num); 
   dbms_output.put_line(' Factorial '|| num || ' is ' || factorial); 
END; 
/

Quando il codice precedente viene eseguito al prompt SQL, produce il seguente risultato:

Factorial 6 is 720 
  
PL/SQL procedure successfully completed.