Oracle Pacchetto PL/SQL: tipo, specifica, corpo [Esempio]

By: Fiona Marrone Fiona Marrone
Hours aggiornato

⚡ Riepilogo intelligente

I pacchetti PL/SQL raggruppano procedure, funzioni, variabili, cursori ed eccezioni correlate in un unico oggetto schema con una specifica e un corpo. La specifica dichiara l'interfaccia pubblica, mentre il corpo contiene l'implementazione privata, migliorando la modularità e le prestazioni.

  • 📦 Definizione del pacchetto: Un pacchetto è un gruppo logicoping di sottoprogrammi e oggetti correlati, compilati e memorizzati come un singolo oggetto di database.
  • 📋 Specifiche della confezione: Dichiara le variabili pubbliche, i cursori, i tipi, le eccezioni, le procedure e le funzioni accessibili dall'esterno del pacchetto.
  • 🧱 Corpo della confezione: Definisce ogni elemento dichiarato nella specifica, oltre agli elementi privati ​​richiamabili solo dall'interno del pacchetto.
  • 🔁 Sovraccarico: Diversi sottoprogrammi possono condividere lo stesso nome anche se il numero dei parametri, i tipi dei parametri o il tipo di ritorno differiscono.
  • 🔗 Riferimento e dipendenza: Gli elementi pubblici vengono chiamati come nome_pacchetto.nome_elemento, e il corpo rimane dipendente dalla specifica.
  • 🤖 Assistenza AI: Gli assistenti IA come GitHub Copilot redigono specifiche di pacchetto, corpi e sottoprogrammi sovraccarichi a partire da un commento.
Scopri di più

Oracle Panoramica delle specifiche e della struttura del corpo del pacchetto PL/SQL

Cos'è il pacchetto in Oracle?

Oracle PL / SQL il pacchetto è un gruppo logicoping di correlati sottoprogrammi (procedura/funzione) in un singolo elemento. Un pacchetto viene compilato e memorizzato come oggetto di database che può essere riutilizzato in seguito.

Componenti dei pacchetti

Un pacchetto PL/SQL ha due componenti.

  • Specifica del pacchetto
  • Corpo del pacchetto

Specifica del pacchetto

La specifica del pacchetto consiste in una dichiarazione di tutti i pacchetti pubblici variabili, cursori, oggetti, procedure, funzioni e eccezioni.

Di seguito sono riportate alcune caratteristiche delle specifiche del pacchetto.

  • Gli elementi dichiarati nella specifica possono essere accessibili dall'esterno del pacchetto. Tali elementi sono noti come elementi pubblici.
  • La specifica del pacchetto è un elemento autonomo, il che significa che può esistere da sola senza un corpo del pacchetto.
  • Ogni volta che si fa riferimento a un pacchetto, viene creata un'istanza del pacchetto per quella specifica sessione.
  • Dopo la creazione dell'istanza per una sessione, tutti gli elementi del pacchetto avviati in tale istanza sono validi fino alla fine della sessione.

Sintassi

CREATE [OR REPLACE] PACKAGE <package_name> 
IS
<sub_program and public element declaration>
.
.
END <package name>

La sintassi sopra riportata mostra la creazione del pacchetto di apprendimento.

Corpo del pacchetto

Il corpo del pacchetto contiene la definizione di tutti gli elementi presenti nella specifica del pacchetto. Può contenere anche definizioni di elementi non dichiarati nella specifica; questi elementi sono chiamati elementi privati ​​e possono essere richiamati solo dall'interno del pacchetto.

Di seguito sono riportate le caratteristiche di un corpo di imballaggio.

  • Dovrebbe contenere le definizioni di tutti i sottoprogrammi/cursori dichiarati nella specifica.
  • Può inoltre contenere ulteriori sottoprogrammi o altri elementi non dichiarati nella specifica. Questi vengono chiamati elementi privati.
  • Si tratta di un oggetto dipendente, e la sua dipendenza risiede nelle specifiche del pacchetto.
  • Lo stato del corpo del pacchetto diventa "Non valido" ogni volta che la specifica viene compilata. Pertanto, è necessario ricompilarlo ogni volta dopo la compilazione della specifica.
  • Gli elementi privati ​​dovrebbero essere definiti prima di essere utilizzati nel corpo del pacchetto.
  • La prima parte del corpo del pacchetto è la parte di dichiarazione globale. Questa include variabili, cursori ed elementi privati ​​(dichiarazione anticipata) che sono visibili all'intero pacchetto.
  • L'ultima parte del pacchetto è la parte di inizializzazione del pacchetto, che viene eseguita una sola volta ogni volta che un pacchetto viene richiamato per la prima volta nella sessione.

Sintassi:

CREATE [OR REPLACE] PACKAGE BODY <package_name>
IS
<global_declaration part>
<Private element definition>
<sub_program and public element definition>
.
<Package Initialization> 
END <package_name>

La sintassi sopra riportata mostra la creazione del corpo del pacchetto.

Ora vedremo come fare riferimento agli elementi del pacchetto nel programma.

Elementi del pacchetto di riferimento

Una volta che gli elementi sono stati dichiarati e definiti nel pacchetto, dobbiamo fare riferimento ad essi per poterli utilizzare.

Tutti gli elementi pubblici del pacchetto possono essere richiamati chiamando il nome del pacchetto seguito dal nome dell'elemento separati da un punto, ovvero ' . '.

Le variabili pubbliche del pacchetto possono essere utilizzate allo stesso modo per assegnare e recuperare valori da esse, vale a dire ' . '.

Crea pacchetto in PL/SQL

In PL/SQL, ogni volta che un pacchetto viene richiamato o utilizzato in una sessione, viene creata una nuova istanza per quel pacchetto.

Oracle fornisce la possibilità di inizializzare gli elementi del pacchetto o di eseguire qualsiasi attività al momento della creazione di questa istanza tramite "Inizializzazione del pacchetto".

Si tratta semplicemente di un blocco di esecuzione che viene scritto nel corpo del pacchetto dopo aver definito tutti gli elementi del pacchetto stesso. Questo blocco verrà eseguito ogni volta che un pacchetto viene richiamato per la prima volta nella sessione.

Lo screenshot qui sotto mostra come il blocco di inizializzazione del pacchetto viene inserito all'interno del corpo del pacchetto durante la sua creazione.

Creazione di un pacchetto PL/SQL con un blocco di inizializzazione del pacchetto nel corpo del pacchetto

Sintassi

CREATE [OR REPLACE] PACKAGE BODY <package_name>
IS
<Private element definition>
<sub_program and public element definition>
.
BEGIN
<Package Initialization> 
END <package_name>

La sintassi precedente mostra la definizione di inizializzazione del pacchetto nel corpo del pacchetto.

ARTICOLI CORRELATI

Dichiarazioni anticipate

La dichiarazione anticipata o il riferimento nel pacchetto non è altro che la dichiarazione separata degli elementi privati ​​e la loro definizione nella parte successiva del corpo del pacchetto.

Gli elementi privati ​​possono essere richiamati solo se sono già stati dichiarati nel corpo del pacchetto. Per questo motivo si utilizza la dichiarazione anticipata. Tuttavia, il suo utilizzo è piuttosto insolito, poiché nella maggior parte dei casi gli elementi privati ​​vengono dichiarati e definiti nella prima parte del corpo del pacchetto.

La dichiarazione anticipata è un'opzione fornita da OracleNon è obbligatorio, e il suo utilizzo o meno dipende dalle esigenze del programmatore.

Lo screenshot qui sotto mostra come un elemento privato viene dichiarato in anticipo e successivamente definito nel corpo del pacchetto.

Dichiarazione anticipata di un elemento privato in un Oracle corpo del pacchetto PL/SQL

Sintassi:

CREATE [OR REPLACE] PACKAGE BODY <package_name>
IS
<Private element declaration>
.
.
.
<Public element definition that refer the above private element>
.
.
<Private element definition> 
.
BEGIN
<package_initialization code>; 
END <package_name>

La sintassi sopra mostra la dichiarazione in avanti. Gli elementi privati ​​sono dichiarati separatamente nella parte in avanti del pacchetto e sono stati definiti nella parte successiva.

Utilizzo dei cursori nel pacchetto

A differenza di altri elementi, bisogna fare attenzione quando si utilizzano i cursori all'interno del pacchetto.

Se il cursore è definito nella specifica del pacchetto o nella parte globale del corpo del pacchetto, allora, una volta aperto, il cursore persisterà fino alla fine della sessione.

Pertanto, è sempre opportuno utilizzare l'attributo del cursore '%ISOPEN' per verificare lo stato del cursore prima di farvi riferimento.

Sovraccarico

Il termine "overloading" si riferisce al concetto di avere più sottoprogrammi con lo stesso nome. Questi sottoprogrammi si differenziano tra loro per il numero di parametri, i tipi di parametri o il tipo di ritorno. In altre parole, si parla di overloading quando si utilizzano sottoprogrammi con lo stesso nome ma con un numero diverso di parametri, tipi di parametri diversi o un tipo di ritorno diverso.

Questo approccio è utile quando molti sottoprogrammi devono svolgere la stessa attività, ma la modalità di chiamata di ciascuno di essi deve essere diversa. In questo caso, il nome del sottoprogramma rimane lo stesso per tutti, mentre i parametri vengono modificati in base all'istruzione di chiamata.

Esempio 1: In questo esempio, creeremo un pacchetto per ottenere e impostare i valori delle informazioni di un dipendente nella tabella 'emp'. La funzione get_record restituirà il tipo di record corrispondente al numero di dipendente specificato, mentre la procedura set_record inserirà il tipo di record corrispondente nella tabella 'emp'.

Fase 1) Creazione delle specifiche del pacchetto

Lo screenshot qui sotto mostra la specifica del pacchetto guru99_get_set in fase di creazione in Oracle.

Creazione della specifica del pacchetto guru99_get_set con set_record e get_record in Oracle

CREATE OR REPLACE PACKAGE guru99_get_set
IS
PROCEDURE set_record (p_emp_rec IN emp%ROWTYPE);
FUNCTION get_record (p_emp_no IN NUMBER) RETURN emp%ROWTYPE;
END guru99_get_set;
/

Produzione:

Package created

Code Spiegazione

  • Code righe 1-5: Creazione della specifica del pacchetto per guru99_get_set con una procedura e una funzione. Queste due sono ora elementi pubblici di questo pacchetto.

Passo 2) Il pacchetto contiene un corpo, dove vengono definite le procedure e le funzioni effettive. In questa fase, viene creato il corpo del pacchetto.

Lo screenshot qui sotto mostra la definizione del corpo del pacchetto guru99_get_set in Oracle.

Definizione del corpo del pacchetto guru99_get_set con set_record, get_record e il blocco di inizializzazione

CREATE OR REPLACE PACKAGE BODY guru99_get_set
IS
PROCEDURE set_record(p_emp_rec IN emp%ROWTYPE)
IS
PRAGMA AUTONOMOUS_TRANSACTION;
BEGIN
INSERT INTO emp
VALUES(p_emp_rec.emp_name,p_emp_rec.emp_no, p_emp_rec.salary,p_emp_rec.manager);
COMMIT;
END set_record;
FUNCTION get_record(p_emp_no IN NUMBER)
RETURN emp%ROWTYPE
IS
l_emp_rec emp%ROWTYPE;
BEGIN
SELECT * INTO l_emp_rec FROM emp where emp_no=p_emp_no;
RETURN l_emp_rec;
END get_record;
BEGIN
dbms_output.put_line('Control is now executing the package initialization part');
END guru99_get_set;
/

Produzione:

Package body created

Code Spiegazione

  • Code riga 7: Creazione del corpo del pacchetto.
  • Code righe 9-16: Definizione dell'elemento 'set_record' dichiarato nella specifica. Ciò equivale a definire una procedura autonoma in PL/SQL.
  • Code righe 17-24: Definizione dell'elemento 'get_record'. È equivalente alla definizione di una funzione autonoma.
  • Code righe 25-26: Definizione della parte di inizializzazione del pacchetto.

Passo 3) Creazione di un blocco anonimo per inserire e visualizzare i record facendo riferimento al pacchetto creato in precedenza.

Lo screenshot qui sotto mostra il blocco anonimo che richiama il pacchetto, insieme al suo output in Oracle.

Blocco anonimo che chiama guru99_get_set per inserire e visualizzare un record dipendente con output

DECLARE
l_emp_rec emp%ROWTYPE;
l_get_rec emp%ROWTYPE;
BEGIN
dbms_output.put_line('Insert new record for employee 1004');
l_emp_rec.emp_no:=1004;
l_emp_rec.emp_name:='CCC';
l_emp_rec.salary:=20000;
l_emp_rec.manager:='BBB';
guru99_get_set.set_record(l_emp_rec);
dbms_output.put_line('Record inserted');
dbms_output.put_line('Calling get function to display the inserted record');
l_get_rec:=guru99_get_set.get_record(1004);
dbms_output.put_line('Employee name: '||l_get_rec.emp_name);
dbms_output.put_line('Employee number:'||l_get_rec.emp_no);
dbms_output.put_line('Employee salary:'||l_get_rec.salary);
dbms_output.put_line('Employee manager:'||l_get_rec.manager);
END;
/

Produzione:

Insert new record for employee 1004
Control is now executing the package initialization part
Record inserted
Calling get function to display the inserted record
Employee name: CCC
Employee number: 1004
Employee salary: 20000
Employee manager: BBB

Code Spiegazione:

  • Code righe 34-37: Popolamento dei dati per la variabile di tipo record in un blocco anonimo per richiamare l'elemento 'set_record' del pacchetto.
  • Code riga 38: È stata effettuata una chiamata al metodo 'set_record' del pacchetto guru99_get_set. Il pacchetto è stato quindi istanziato e rimarrà attivo fino alla fine della sessione. Poiché si tratta della prima chiamata al pacchetto, viene eseguita la fase di inizializzazione e il record viene inserito nella tabella tramite l'elemento 'set_record'.
  • Code riga 41: Viene richiamato l'elemento 'get_record' per visualizzare i dettagli del dipendente inserito. Il pacchetto viene richiamato una seconda volta durante questa chiamata, ma la parte di inizializzazione non viene eseguita nuovamente, poiché il pacchetto è già stato inizializzato in questa sessione.
  • Code righe 42-45: Stampa dei dati del dipendente.

Dipendenza dai pacchetti

Poiché il pacchetto è un gruppo logicoping Per quanto riguarda gli elementi correlati, presenta alcune dipendenze. Di seguito sono elencate le dipendenze di cui è necessario tenere conto.

  • Una specifica è un oggetto autonomo.
  • Il corpo di un pacchetto dipende dalle specifiche.
  • Il corpo del pacchetto può essere compilato separatamente. Ogni volta che la specifica viene compilata, il corpo deve essere ricompilato, poiché diventerà non valido.
  • La sottoprogramma all'interno del corpo del pacchetto che dipende da un elemento privato deve essere definita solo dopo la dichiarazione dell'elemento privato.
  • Gli oggetti del database a cui si fa riferimento nella specifica e nel corpo del documento devono trovarsi in uno stato valido al momento della compilazione del pacchetto.

Informazioni sul pacchetto

Una volta creato il pacchetto, le informazioni sul pacchetto, come la sorgente del pacchetto, i dettagli del sottoprogramma e i dettagli del sovraccarico, sono disponibili nel Oracle tabelle del dizionario dati.

La tabella seguente riporta la struttura del dizionario dati e le informazioni sui pacchetti disponibili in ciascuna tabella.

Nome tabella Descrizione domanda
TUTTI_OGGETTI Fornisce i dettagli del pacchetto, come object_id, creation_date, last_ddl_time, ecc. Contiene gli oggetti creati da tutti gli utenti. SELECT * FROM all_objects dove nome_oggetto =' '
OGGETTI_UTENTE Fornisce i dettagli del pacchetto, come object_id, creation_date, last_ddl_time, ecc. Contiene gli oggetti creati dall'utente corrente. SELECT * FROM oggetti_utente dove nome_oggetto =' '
TUTTO_FONTE Fornisce l'origine degli oggetti creati da tutti gli utenti. SELECT * FROM all_source dove nome=' '
UTENTE_SOURCE Fornisce l'origine degli oggetti creati dall'utente corrente. SELECT * FROM origine_utente dove nome=' '
TUTTE_PROCEDURE Fornisce i dettagli del sottoprogramma, come object_id, dettagli di overload, ecc., creati da tutti gli utenti. SELECT * FROM all_procedures WHERE object_name=' '
PROCEDURE_UTENTE Fornisce dettagli sul sottoprogramma, come object_id, dettagli sul sovraccarico, ecc., creato dall'utente corrente. SELECT * FROM user_procedures WHERE object_name=' '

UTL_FILE – Una panoramica

UTL_FILE è un pacchetto di utilità separato fornito da Oracle Per eseguire compiti speciali. Viene utilizzato principalmente per leggere e scrivere file del sistema operativo da pacchetti o sottoprogrammi PL/SQL. Dispone di funzioni separate per inserire e recuperare informazioni dai file. Consente inoltre la lettura e la scrittura nel set di caratteri nativo.

Il programmatore può utilizzare questo strumento per scrivere file di sistema operativo di qualsiasi tipo, che verranno scritti direttamente sul server del database. Il nome e il percorso della directory vengono specificati al momento della scrittura.

DOMANDE FREQUENTI

I pacchetti offrono modularità, occultamento delle informazioni e una progettazione più semplice delle applicazioni. La specifica espone un'interfaccia pubblica, mentre il corpo nasconde l'implementazione. Oracle Carica un pacchetto in memoria alla prima chiamata, in modo che le successive chiamate ai sottoprogrammi evitino l'I/O su disco e vengano eseguite più velocemente.

Un pacchetto raggruppa molti correlati sottoprogrammi e oggetti condivisi sotto un unico nome, separando una specifica pubblica da un corpo privato. Una procedura o funzione autonoma è un singolo oggetto schema indipendente, senza tale separazione tra interfaccia e implementazione.

Sì, se la specifica dichiara solo variabili, costanti, tipi o eccezioni. Il corpo diventa obbligatorio nel momento in cui la specifica dichiara una qualsiasi procedura, funzione o cursore, perché il corpo deve fornirne l'implementazione. Altrimenti, la specifica può essere autonoma.

Utilizzare DROP PACKAGE per rimuovere sia la specifica che il corpo, oppure DROP PACKAGE BODY per rimuovere solo il corpo. Ricompilare un pacchetto non valido con ALTER PACKAGE package_name COMPILE, oppure COMPILE BODY per ricostruire solo il corpo dopo le modifiche.

L'attributo %ROWTYPE dichiara un record i cui campi corrispondono alle colonne della tabella emp. L'utilizzo di emp%ROWTYPE mantiene i parametri get_record e set_record allineati alla struttura della tabella, in modo che le modifiche alle colonne richiedano meno modifiche al codice.

Sì. Ogni sessione che fa riferimento a un pacchetto ottiene la propria istanza e il proprio stato del pacchetto, che persistono per tutta la durata della sessione. La ricompilazione del corpo scarta lo stato e genera l'errore ORA-04068 alla chiamata successiva.

Sì. Le serrature scorrevoli portatili e i catenacci a superficie possono essere usati per mettere in sicurezza una porta a scomparsa dall'esterno. Alcuni kit con catena di sicurezza consentono anche il bloccaggio esterno con chiave o manopola girevole. Copilota GitHub elabora le specifiche del pacchetto, i corpi corrispondenti e i sottoprogrammi sovraccaricati a partire da un commento e suggerisce i parametri %ROWTYPE. RevPrima della distribuzione, visualizza i limiti generati, il blocco di inizializzazione e la gestione delle eccezioni.

Gli assistenti basati sull'intelligenza artificiale analizzano un pacchetto alla ricerca di stati non validi, definizioni del corpo mancanti e catene di dipendenze che si interrompono quando le specifiche cambiano. Questa revisione tramite apprendimento automatico segnala sottoprogrammi sovraccarichi ambigui e rischi di ricompilazione prima che il pacchetto raggiunga l'ambiente di produzione.

Riassumi questo post con: