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

O que é o pacote Oracle?

Oracle PL/SQL pacote é um grupo lógicoping de relacionado subprogramas (procedimento/função) em um único elemento. Um pacote é compilado e armazenado como um objeto de banco de dados que pode ser reutilizado posteriormente.

Componentes de Pacotes

Um 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 públicos variáveis, cursores, objetos, procedimentos, funções e exceções.

A seguir, apresentamos 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 elementos públicos.
• A especificação do pacote é um elemento independente, o que significa que pode existir sozinha, sem um corpo de 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

O corpo do pacote consiste na definição de todos os elementos presentes na especificação do pacote. Ele também pode conter definições de elementos que não foram declarados na especificação; esses elementos são chamados de elementos privados e só podem ser acessados ​​de dentro do pacote.

A seguir estão as características de um corpo de embalagem.

• Deve conter as definições de todos os subprogramas/cursores que foram declarados na especificação.
• Também pode conter mais subprogramas ou outros elementos que não estão declarados na especificação. Esses são chamados de elementos privados.
• É um objeto dependente 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 a cada vez 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 corpo do pacote é a parte de declaração global. Isso inclui variáveis, cursores e elementos privados (declaração antecipada) que são visíveis para todo o pacote.
• A última parte do pacote é a parte de inicialização do pacote, que é executada uma única vez sempre que um pacote é referenciado 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 vamos ver como fazer referência a elementos de pacote no programa.

Referindo Elementos do Pacote

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

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

As variáveis ​​públicas do pacote também podem ser usadas da mesma forma para atribuir e obter valores delas, ou seja, ' . '.

Criar pacote em PL/SQL

Em PL/SQL, sempre que um pacote é referenciado ou chamado em uma sessão, uma nova instância é 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'.

Trata-se simplesmente de um bloco de execução escrito no corpo do pacote após a definição de todos os seus elementos. Esse bloco será executado sempre que um pacote for referenciado pela primeira vez na sessão.

A captura de tela abaixo mostra como o bloco de inicialização do pacote é colocado dentro do corpo do pacote ao criar um pacote.

Sintaxe

CREATE [OR REPLACE] PACKAGE BODY <package_name>
IS
<Private element definition>
<sub_program and public element definition>
.
BEGIN
<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 ou referência antecipada em um pacote nada mais é do que declarar os elementos privados separadamente e defini-los posteriormente no corpo do pacote.

Elementos privados só podem ser referenciados se já estiverem declarados no corpo do pacote. Por esse motivo, utiliza-se a declaração antecipada. No entanto, seu uso é incomum, pois 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 OracleNão é obrigatório, e o seu uso ou não fica a critério do programador.

A captura de tela abaixo mostra como um elemento privado é declarado antecipadamente e posteriormente definido no corpo do pacote.

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

Diferentemente 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, uma vez aberto, o cursor permanecerá visível até o final da sessão.

Portanto, deve-se sempre usar o atributo do cursor '%ISOPEN' para verificar o estado do cursor antes de se referir a ele.

Sobrecarregando

Sobrecarga é o conceito de ter vários subprogramas com o mesmo nome. Esses subprogramas diferem entre si pelo número de parâmetros, pelos tipos de parâmetros ou pelo tipo de retorno. Em outras palavras, subprogramas com o mesmo nome, mas com número diferente de parâmetros, tipos diferentes de parâmetros ou tipos de retorno diferentes, são considerados sobrecarga.

Isso é útil quando várias sub-rotinas precisam executar a mesma tarefa, mas a forma de chamar cada uma delas deve ser diferente. Nesse caso, o nome da sub-rotina permanece o mesmo para todas, e os parâmetros são alterados de acordo com a instrução de chamada.

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

Etapa 1) Criação da especificação do pacote

A captura de tela abaixo mostra a especificação do pacote guru99_get_set sendo criada em 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;
/

Saída:

Package created

Code Explicação

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

Passo 2) O pacote contém um corpo de pacote, onde são definidas as definições reais de todos os procedimentos e funções. Nesta etapa, o corpo do pacote é criado.

A captura de tela abaixo mostra a definição do corpo do pacote guru99_get_set em Oracle.

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

Saída:

Package body created

Code Explicação

• Code linha 7: Criando o corpo do pacote.
• Code linhas 9-16: Definir o elemento 'set_record' que é declarado na especificação. Isso é o mesmo que definir um procedimento independente em PL/SQL.
• Code linhas 17-24: Definir o elemento 'get_record' é o mesmo que definir uma função independente.
• Code linhas 25-26: Definindo a parte de inicialização do pacote.

Passo 3) Criando um bloco anônimo para inserir e exibir os registros, fazendo referência ao pacote criado anteriormente.

A captura de tela abaixo mostra o bloco anônimo que chama o pacote, juntamente com sua saída em Oracle.

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

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

Code Explicação:

• Code linhas 34-37: Preencher os dados da variável de tipo de registro em um bloco anônimo para chamar o elemento 'set_record' do pacote.
• Code linha 38: Foi feita uma chamada 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 ao pacote, e o registro é inserido na tabela pelo elemento 'set_record'.
• Code linha 41: Chamando o elemento 'get_record' para exibir os detalhes do funcionário inserido. O pacote é referenciado pela segunda vez durante esta chamada, mas a parte de inicialização não é executada novamente, pois o pacote já está inicializado nesta sessão.
• Code linhas 42-45: Imprimindo os dados do funcionário.

Dependência em Pacotes

Como o pacote é um grupo lógicoping Dentre os itens relacionados, existem algumas dependências. A seguir, estão as dependências que devem ser consideradas.

• Uma especificação é um objeto independente.
• O conteúdo da embalagem depende da especificação.
• O corpo do pacote pode ser compilado separadamente. Sempre que a especificação for compilada, o corpo precisará 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 do pacote precisam estar em um estado válido no momento da compilação.

Informações do pacote

Após a criação do pacote, as informações do pacote, como a origem do pacote, detalhes do subprograma e detalhes de sobrecarga, ficam disponíveis no Oracle Tabelas do dicionário de dados.

A tabela abaixo apresenta a tabela do dicionário de dados e as informações do pacote disponíveis em cada tabela.

UTL_FILE – Uma Visão Geral

UTL_FILE é um pacote de utilitários separado fornecido por Oracle Para executar tarefas especiais. É usado principalmente para ler e gravar arquivos do sistema operacional a partir de pacotes ou subprogramas PL/SQL. Possui funções separadas para inserir e obter informações de arquivos. Também permite leitura e gravação no conjunto de caracteres nativo.

O programador pode usar isso para escrever 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 são mencionados no momento da gravação.

Perguntas Frequentes