Oracle Pacote PL/SQL: Tipo, Especificação, Corpo [Exemplo]

O que é o pacote Oracle?

O pacote PL/SQL é um agrupamento lógico de um subprograma relacionado (procedimento/função) em um único elemento. Um pacote é compilado e armazenado como um objeto de banco de dados que pode ser usado posteriormente.

Componentes de Pacotes

O pacote PL/SQL possui dois componentes.

• Especificação do Pacote
• Corpo do pacote

Especificação do Pacote

A especificação do pacote consiste em uma declaração de todos os variáveis, cursores, objetos, procedimentos, funções e exceção.

Abaixo estão algumas características da especificação do pacote.

• Os elementos declarados na especificação podem ser acessados ​​de fora do pacote. Esses elementos são conhecidos como elemento público.
• A especificação do pacote é um elemento independente, o que significa que pode existir sozinho, sem o corpo do pacote.
• Sempre que um pacote é referenciado, uma instância do pacote é criada para aquela sessão específica.
• Depois que a instância for criada para uma sessão, todos os elementos do pacote iniciados nessa instância serão válidos até o final da sessão.

Sintaxe

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

A sintaxe acima mostra a criação da especificação do pacote.

Corpo do pacote

Consiste na definição de todos os elementos que estão presentes na especificação do pacote. Também pode ter uma definição de elementos que não estão declarados na especificação, esses elementos são chamados de elementos privados e podem ser chamados apenas de dentro do pacote.

Abaixo estão as características de um corpo de pacote.

• Deve conter definições para todos os subprogramas/cursores que foram declarados na especificação.
• Também pode ter mais subprogramas ou outros elementos que não estão declarados na especificação. Estes são chamados de elementos privados.
• É um objeto confiável e depende da especificação do pacote.
• O estado do corpo do pacote torna-se 'Inválido' sempre que a especificação é compilada. Portanto, ele precisa ser recompilado sempre após a compilação da especificação.
• Os elementos privados devem ser definidos primeiro, antes de serem usados ​​no corpo do pacote.
• A primeira parte do pacote é a parte da declaração global. Isto inclui variáveis, cursores e elementos privados (declaração direta) que são visíveis para todo o pacote.
• A última parte do pacote é a parte de inicialização do pacote, que é executada uma vez sempre que um pacote é referido pela primeira vez na sessão.

Sintaxe:

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>

• A sintaxe acima mostra a criação do corpo do pacote.

Agora veremos como fazer referência aos elementos do pacote no programa.

Referindo Elementos do Pacote

Uma vez que os elementos são declarados e definidos no pacote, precisamos referenciá-los para utilizá-los.

Todos os elementos públicos do pacote podem ser consultados chamando o nome do pacote seguido pelo nome do elemento separado por ponto, ou seja, ' . '.

A variável pública do pacote também pode ser usada da mesma maneira para atribuir e buscar valores deles, ou seja, ' . '.

Criar pacote em PL/SQL

Em PL/SQL sempre que um pacote é referido/chamado em uma sessão, uma nova instância será criada para esse pacote.

Oracle fornece um recurso para inicializar elementos do pacote ou realizar qualquer atividade no momento da criação desta instância por meio de 'Inicialização do pacote'.

Isso nada mais é do que um bloco de execução escrito no corpo do pacote após definir todos os elementos do pacote. Este bloco será executado sempre que um pacote for referenciado pela primeira vez na sessão.

Sintaxe

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

• A sintaxe acima mostra a definição de inicialização do pacote no corpo do pacote.

Declarações para a frente

A declaração/referência direta no pacote nada mais é do que declarar os elementos privados separadamente e defini-los na parte posterior do corpo do pacote.

Elementos privados só podem ser referenciados se já estiverem declarados no corpo do pacote. Por esse motivo, a declaração direta é usada. Mas é bastante incomum de usar porque na maioria das vezes os elementos privados são declarados e definidos na primeira parte do corpo do pacote.

A declaração futura é uma opção fornecida por Oracle, não é obrigatório e usar e não usar fica a critério do programador.

Sintaxe:

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>

A sintaxe acima mostra a declaração direta. Os elementos privados são declarados separadamente na parte anterior do pacote e foram definidos na parte posterior.

Uso de cursores no pacote

Ao contrário de outros elementos, é preciso ter cuidado ao usar cursores dentro do pacote.

Se o cursor estiver definido na especificação do pacote ou na parte global do corpo do pacote, então o cursor, uma vez aberto, persistirá até o final da sessão.

Portanto, deve-se sempre usar os atributos do cursor '%ISOPEN' para verificar o estado do cursor antes de referenciá-lo.

Sobrecarregando

Sobrecarga é o conceito de ter muitos subprogramas com o mesmo nome. Esses subprogramas serão diferentes entre si por um número de parâmetros ou tipos de parâmetros ou tipo de retorno, ou seja, subprogramas com o mesmo nome, mas com número diferente de parâmetros, tipos diferentes de parâmetros ou redigitações diferentes são considerados sobrecarga.

Isto é útil quando muitos subprogramas precisam realizar a mesma tarefa, mas a forma de chamar cada um deles deve ser diferente. Neste caso, o nome do subprograma será mantido igual para todos e os parâmetros serão alterados conforme a instrução de chamada.

Exemplo 1: Neste exemplo, vamos criar um pacote para obter e definir os valores das informações do funcionário na tabela 'emp'. A função get_record retornará a saída do tipo de registro para o número de funcionário fornecido, e o procedimento set_record inserirá o registro do tipo de registro na tabela emp.

Passo 1) Criação de especificação de pacote

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:
/

Saída:

Package created

Explicação do código

• Linha de código 1-5: Criando a especificação do pacote para guru99_get_set com um procedimento e uma função. Estes dois são agora elementos públicos deste pacote.

Passo 2) O pacote contém o corpo do pacote, onde serão definidas todas as definições reais de procedimentos e funções. Nesta etapa, o Corpo do Pacote é criado.

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;
BEGUN	
dbms_output.put_line(‘Control is now executing the package initialization part');
END guru99_get_set:
/

Saída:

Package body created

Explicação do código

• Linha de código 7: Criando o corpo do pacote.
• Linha de código 9-16: Definindo o elemento 'set_record' que é declarado na especificação. Isso é o mesmo que definir o procedimento independente em PL/SQL.
• Linha de código 17-24: Definindo o elemento 'get_record'. É o mesmo que definir a função autônoma.
• Linha de código 25-26: Definindo a parte de inicialização do pacote.

Passo 3) Criando um bloco anônimo para inserir e exibir os registros consultando o pacote criado acima.

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:=l004;
l_emp_rec.emp_name:='CCC';
l_emp_rec.salary~20000;
l_emp_rec.manager:=’BBB’;
guru99_get_set.set_record(1_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:‘||1_get_rec.manager);		
END:
/

Saída:

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

Explicação do código:

• Linha de código 34-37: Preencher os dados da variável do tipo de registro em um bloco anônimo para chamar o elemento 'set_record' do pacote.
• Linha de código 38: A chamada foi feita para 'set_record' do pacote guru99_get_set. Agora o pacote está instanciado e persistirá até o final da sessão.
• A parte de inicialização do pacote é executada, pois esta é a primeira chamada do pacote.
• O registro é inserido pelo elemento 'set_record' na tabela.
• Linha de código 41: Chamando o elemento 'get_record' para exibir os detalhes do funcionário inserido.
• O pacote é referido pela segunda vez durante a chamada 'get_record' para o pacote. Mas a parte de inicialização não é executada desta vez porque o pacote já foi inicializado nesta sessão.
• Linha de código 42-45: Imprimindo os dados do funcionário.

Dependência em Pacotes

Como o pacote é o agrupamento lógico de coisas relacionadas, ele possui algumas dependências. A seguir estão as dependências que devem ser cuidadas.

• Uma especificação é um objeto independente.
• O corpo de um pacote depende da especificação.
• O corpo do pacote pode ser compilado separadamente. Sempre que a especificação é compilada, o corpo precisa ser recompilado, pois se tornará inválido.
• O subprograma no corpo do pacote que depende de um elemento privado deve ser definido somente após a declaração do elemento privado.
• Os objetos de banco de dados mencionados na especificação e no corpo precisam estar com status válido no momento da compilação do pacote.

Informações do pacote

Depois que as informações do pacote são criadas, as informações do pacote, como origem do pacote, detalhes do subprograma e detalhes de sobrecarga, ficam disponíveis no Oracle tabelas de definição de dados.

A tabela abaixo fornece a tabela de definição de dados e as informações do pacote que estão disponíveis na tabela.

Nome da tabela	Descrição	pergunta
ALL_OBJECT	Fornece os detalhes do pacote como object_id, Creation_date, last_ddl_time, etc. Ele conterá os objetos criados por todos os usuários.	SELECT * FROM all_objects onde object_name =' '
USER_OBJECT	Fornece os detalhes do pacote como object_id, Creation_date, last_ddl_time, etc. Ele conterá os objetos criados pelo usuário atual.	SELECT * FROM user_objects onde object_name =' '
ALL_SOURCE	Fornece a origem dos objetos criados por todos os usuários.	SELECIONE * FROM all_source onde nome=' '
USER_SOURCE	Fornece a origem dos objetos criados pelo usuário atual.	SELECIONE * FROM user_source onde nome=' '
TODOS_PROCEDIMENTOS	Fornece detalhes do subprograma como object_id, detalhes de sobrecarga, etc., criados por todos os usuários.	SELECIONE *FROM todos_procedimentos Onde object_name=' '
USER_PROCEDURES	Fornece detalhes do subprograma como object_id, detalhes de sobrecarga, etc. criados pelo usuário atual.	SELECIONE *FROM user_procedures Onde object_name=' '

ARQUIVO UTL – Uma Visão Geral

Arquivo UTL é o pacote de utilitários separado fornecido por Oracle para realizar tarefas especiais. Isso é usado principalmente para ler e gravar arquivos do sistema operacional de pacotes ou subprogramas PL/SQL. Ele tem funções separadas para colocar as informações e obter as informações dos arquivos. Também permite ler/escrever no conjunto de caracteres nativo.

O Programador pode usar isso para gravar arquivos do sistema operacional de qualquer tipo e o arquivo será gravado diretamente no servidor de banco de dados. O nome e o caminho do diretório serão mencionados no momento da escrita.

Resumo

Agora aprendemos os pacotes em PL/SQL, e agora você deve ser capaz de trabalhar no seguinte.

• Pacotes PL/SQL e seus componentes
• Características dos pacotes
• Referindo e sobrecarregando elementos do pacote
• Gerenciando dependências em pacotes
• Visualizando informações do pacote
• O que é arquivo UTL