Guia de Consulta Rápida

Oracle 9i
PL / SQL
Celso H. Poderoso de Oliveira

Novatec Editora
www.novateceditora.com.br
Guia de Consulta Rápida Oracle 9i PL/SQL
de Celso H. Poderoso de Oliveira

Copyright2002 da Novatec Editora Ltda.

Todos os direitos reservados. É proibida a reprodução

desta obra, mesmo parcial, por qualquer processo, sem
prévia autorização, por escrito, do autor e da Editora.

ISBN: 85-7522-032-2

Novatec Editora Ltda.

Rua Cons. Moreira de Barros 1084 Conj. 01
02018-012 São Paulo - SP Brasil
Tel.: (0xx11) 6959-6529
Fax: (0xx11) 6950-8869
E-mail: novatec@novateceditora.com.br
Site: www.novateceditora.com.br

2
 Sumário
Introdução .................................................................................................. 5
Comando SELECT INTO .................................................................... 8
Utilização de pseudocolunas ................................................................ 8
Dados ......................................................................................................... 9
Delimitadores ....................................................................................... 9
Literais ............................................................................................... 10
Comentários ....................................................................................... 10
Tipos de dados ................................................................................... 10
Subtipos definidos pelo usuário ......................................................... 13
Conversão de dados ........................................................................... 13
Declarações ........................................................................................ 13
Escopo e visibilidade ......................................................................... 15
Expressões e comparações ................................................................. 15
Expressões Booleanas ........................................................................ 16
Dicas de utilização de Expressões Booleanas .................................... 17
Expressões CASE .............................................................................. 18
Ferramentas de desenvolvimento ............................................................ 19
SQL*Plus ........................................................................................... 20
SQL*Plus Worksheet ......................................................................... 24
Estruturas de controle .............................................................................. 26
Controle de fluxo – IF ........................................................................ 26
Controle de Fluxo – CASE ................................................................ 27
Controle de repetição – LOOP ........................................................... 28
FOR-LOOP ........................................................................................ 30
Controle de seqüência – GOTO e NULL ........................................... 31
Utilização de variáveis ....................................................................... 32
PROMPT ............................................................................................ 33
ACCEPT ............................................................................................ 33
Collections e records ............................................................................... 36
Uso de Collections ............................................................................. 36
Manipulação de collections ................................................................ 38
PL/SQL e Comandos SQL ................................................................. 39
Métodos utilizados em collections ..................................................... 40
Manipulação de erros de collections .................................................. 41
Melhorando o desempenho ................................................................ 41
Definição de mais dimensões ............................................................. 42
Uso de records .................................................................................... 43
Manipulação de records ..................................................................... 44
Simplificando Código ........................................................................ 44
Cursores ................................................................................................... 45
Cursores explícitos ............................................................................. 45
Cursores implícitos ............................................................................ 47
Utilização do comando FOR .............................................................. 47
Variáveis do tipo Cursor ..................................................................... 48
Subqueries x Cursores Explícitos ...................................................... 50
Expressões CURSOR ......................................................................... 50
Transações ............................................................................................... 52
Processamento de transações ............................................................. 52
Two Fase Commit .............................................................................. 53
Mecanismos de bloqueio .................................................................... 53
Transações autônomas - PRAGMA ................................................... 53
LOCK TABLE ................................................................................... 54
DBMS_LOCK ................................................................................... 54
Tratamento de erros ................................................................................. 55
Exceções predefinidas ........................................................................ 56
Exceções criadas pelo usuário ........................................................... 57
Uso do RAISE_APPLICATION_ERROR ......................................... 58

3
Sumário
Subprogramas .......................................................................................... 59
Procedimentos .................................................................................... 59
Comandos relacionados a procedimentos .......................................... 60
Funções .............................................................................................. 61
Comandos relacionados a funções ..................................................... 63
Declaração de subprogramas ............................................................. 64
Chamando programas externos .......................................................... 65
Atribuindo direitos de execução ........................................................ 65
Pacotes ..................................................................................................... 66
Especificação do pacote ..................................................................... 66
Corpo do pacote ................................................................................. 67
Comandos relacionados a pacotes ...................................................... 69
Estados do pacote ............................................................................... 69
Objetos ..................................................................................................... 70
Utilizando o Object Type ................................................................... 70
Declaração do Object Type ................................................................ 71
Comparação de Objetos ..................................................................... 72
Troca de Atributos e Métodos ............................................................ 73
Método construtor .............................................................................. 73
Acessando métodos - notação de ponto ............................................. 74
Manipulação de objetos ..................................................................... 75
Utilização de VALUE ........................................................................ 76
Utilização de REF e DEREF .............................................................. 76
Regras gerais para utilização de Object Type .................................... 77
Triggers .................................................................................................... 81
Tipos de Trigger ................................................................................. 81
Triggers DML .................................................................................... 81
Triggers Instead of ............................................................................. 83
Triggers DDL ..................................................................................... 84
Triggers de Banco de Dados .............................................................. 85
Comandos para gerenciamento de triggers ........................................ 85
Dynamic SQL .......................................................................................... 86
Quando utilizar o Dynamic SQL ........................................................ 86
EXECUTE IMMEDIATE .................................................................. 87
Consultas com mais de uma linha de retorno ..................................... 89
Utilização de atributos de cursor ........................................................ 91
Parâmetros de retorno ........................................................................ 91
Utilizando BULK DYNAMIC SQL .................................................. 92
DBMS_SQL ....................................................................................... 92
Utilizando Java com PL/SQL .................................................................. 93
Oracle JVM ........................................................................................ 93
Passos para criação de procedimentos Java no Oracle ....................... 94
Importando as classes Java ................................................................ 94
Publicando classes Java ..................................................................... 98
Parâmetros IN OUT e OUT ............................................................. 101
Ferramenta OJVMJAVA .................................................................. 101
Utilização do driver JDBC ............................................................... 101
Utilização do SQLJ .......................................................................... 103
Apêndices .............................................................................................. 105
PL/SQL Wrapper .............................................................................. 105
Visões relacionadas com subprogramas armazenados ..................... 105
Limites do PL/SQL .......................................................................... 106
Palavras reservadas do PL/SQL e SQL ............................................ 107
Onde obter mais informações ........................................................... 108
Notação utilizada neste guia ............................................................ 108
Comentários e sugestões .................................................................. 108
Sobre o autor .................................................................................... 108

4
 Introdução

Introdução
PL/SQL é a linguagem de programação utilizada para programar
o Banco de Dados Oracle. Com o PL/SQL você pode utilizar
comandos SQL (INSERT, DELETE, UPDATE e SELECT) para
manipular dados do Banco de Dados, além de comandos para
controlar os processos, como testes de condição e repetições.

SQL
Diferentemente de outras linguagens mais antigas de manipulação
de dados, como as linguagens xBase, o SQL é set-oriented, ou
seja, é executada em blocos.
Utilizando o SQL, um comando que manipule diversas linhas da
tabela são executados de uma só vez e não linha por linha. Dessa
forma, garante-se segurança e performance, uma vez que ou tudo
(no caso de uma atualização feita com sucesso) ou nada (em caso
de algum problema de hardware, incluindo queda de energia, ou
mesmo do software) é realizado. A grande vantagem é que se tem
o controle absoluto sobre as transações no Banco de Dados,
eliminando eventuais “registros perdidos” em função de possíveis
problemas.
No tópico de Transações (página 52) você verá como controlar o
momento da gravação dos dados no banco.

PL/SQL
Ao utilizar o PL/SQL, que tem absoluta integração com o SQL,
obtêm-se todas as vantagens da linguagem SQL e ainda a
possibilidade de vincular lógica aos comandos, definindo, dessa
forma, procedimentos.
A programação em PL/SQL guarda muita semelhança com
linguagens procedurais. Uma característica importante é a divisão
de um bloco em diversos blocos de comandos. Desse modo, se as
unidades básicas (procedimentos e funções) são baseadas em
blocos lógicos, e estes, por sua vez, podem conter outros blocos.
O fato de ser chamada procedural pode, para muitos, parecer que
é uma linguagem de concepção “antiga”. Na realidade, a linguagem
PL/SQL vem sendo aprimorada pela Oracle ao longo do tempo.
Possui desde o “mal falado” comando GOTO até a possibilidade
de criar e manter Objetos, atendendo à boa parte dos conceitos da
Orientação a Objetos. Contudo, cada método do objeto deverá, de
qualquer forma, ser programado de maneira procedural.
As seções que compõem um bloco PL/SQL são:
a) Declaração de variáveis - Cláusula DECLARE.
b) Execução de comandos e lógica - Cláusula BEGIN.
c) Exceção ou tratamento de erros - Cláusula EXCEPTION.

5
Introdução

Normalmente esta é a estrutura do bloco PL/SQL:

DECLARE
variáveis;
...
BEGIN
comandos;
...
EXCEPTION
tratamento de erros;
...
END;

A única obrigatória é a seção de Execução, as demais são opcionais.

Conforme dito, dentro de um bloco é possível haver outros.
Abaixo do BEGIN, pode-se incluir nova seção de declaração,
execução e tratamento de erros.

Funcionamento do engine PL/SQL

Oracle Server

Aplicação SGA PL/SQL engine

Processador de
Procedure comandos
Código Begin procedurais
Código ...
Chamada ao SQL
Procedimento ... SQL
END;
Processador de
comandos SQL

Banco de
Dados

6
 Introdução

Veja que os procedimentos são compilados e armazenados no

Banco de Dados. Quando uma aplicação externa chama um
procedimento armazenado, este é requisitado para uma área da
SGA (System Global Area – área de memória que o Oracle utiliza
no servidor) chamada shared pool (área de memória
compartilhada). Por sua vez, cada comando procedural é executado
no engine PL/SQL que, conseqüentemente, requisita, sempre que
necessário, o processador de comandos SQL. Note que ambos os
processadores, tanto o do PL/SQL quantoo do SQL, trabalham de
maneira integrada, o que garante melhor performance na execução
dos blocos.
Esse engine está disponível nas seguintes ferramentas Oracle:
a) Oracle Server.
b) Oracle Forms (a partir da versão 3).
c) SQL*Menu (a partir da versão 5).
d) Oracle Reports (a partir da versão 2).
e) Oracle Graphics (a partir da versão 2).
Um procedimento armazenado pode ser chamado por um bloco
anônimo (não armazenado no banco de dados, mas executado
diretamente nele) ou por outro procedimento armazenado. Você
poderá, também, passar blocos anônimos para o Oracle, utilizando
as seguintes ferramentas:
a) Pré-compiladores Oracle.
b) Oracle Call Interfaces (OCIs).
c) SQL*Plus.
d) Server Manager.
e) Oracle Enterprise Manager.
Existe uma série de pré-compiladores Oracle para diversas
linguagens como C, C++, Cobol etc. Outras ferramentas utilizam
as OCIs para se comunicarem com o Oracle, como o PHP.

Utilidade
Utiliza-se o bloco PL/SQL para criar:
a) Triggers: são programas que devem ser executados após
eventos que ocorrem no Banco de Dados, como Inclusão
(INSERT), Exclusão (DELETE) e Atualização (UPDATE).
b) Procedimentos e funções: programas armazenados no Banco
de Dados que são chamados por aplicações, triggers ou outras
ferramentas.
c) Blocos anônimos: blocos enviados por outros programas,
como o próprio SQL*Plus ou Enterprise Manager que são
compilados e executados no Oracle Server.
d) Pacotes e objetos: armazenam e agrupam funções,
procedimentos, cursores e variáveis.

7
Introdução

Comando SELECT INTO

A principal diferença na utilização de comandos SQL em blocos
PL/SQL está na utilização do comando SELECT.
Sabe-se que o comando SELECT é utilizado para realizar buscas
no banco de dados. No PL/SQL é necessário colocar o resultado
de qualquer busca em variáveis.
Isso se faz especificando a cláusula INTO após a lista de campos,
seguida de tantas variáveis quantos sejam os campos que buscamos
na tabela.
Como resultado da busca podemos ter uma, várias ou nenhuma
linha. Sempre que utilizamos a cláusula INTO, a expectativa do
PL/SQL é que haja uma única linha de retorno.
As duas outras situações deverão ser convenientemente tratadas.
Faremos a verificação dessas situações não esperadas pelo PL/
SQL será visto no tópico de Tratamento de erros (página 55).
Sintaxe:
SELECT lista_campos INTO lista_destino
FROM tabela ...
Parâmetro Descrição
lista_campos Lista de campos que serão selecionadas na tabela.
lista_destino Lista de variáveis que receberá o conteúdo da lista de
campos.
tabela Tabela base de busca.
Note que o número de elementos da lista destino deve coincidir
com o número de elementos da lista de campos. Do contrário, o
PL/SQL reportará um erro na tentativa de execução do comando.

Utilização de pseudocolunas
Pseudocolunas são colunas que não fazem parte da tabela, mas que
têm características de colunas. Toda vez que for feita uma referência
a uma dessas pseudocolunas, elas terão o mesmo comportamento
de outras colunas, retornando valores, por exemplo. O que não se
pode fazer é manipulá-las com instruções do tipo DDL (criação,
alteração, etc.) nem alguns comandos DML (INSERT e UPDATE).
No PL/SQL, pode-se utilizar as seguintes pseudocolunas:
Pseudocoluna Descrição
CURRVAL Valor corrente de uma seqüência armazenada no Banco
de Dados.
NEXTVAL Valor do próximo valor da seqüência armazenada no
Banco de Dados.
LEVEL Nível na estrutura da árvore em bancos de dados remotos.
ROWID Coluna que especifica a localização da linha (definido
pelo Oracle).
ROWNUM Número da linha selecionada em uma tabela. Não é
afetada pela cláusula ORDER BY.

8
 Dados

Dados
Exatamente como todas as linguagens de programação, PL/SQL
tem uma série de exigências que devem ser satisfeitas, como
palavras reservadas, pontuações, sintaxes e tipos de dados.
A linguagem PL/SQL não é sensível a caracteres maiúsculos ou
minúsculos, assim, tanto faz definir uma variável com caixa alta,
baixa ou alta e baixa, ela será interpretada da mesma forma.
Variáveis em PL/SQL podem conter até 30 caracteres iniciando
sempre por uma letra. Podem-se utilizar números e os símbolos $
_ #. Os demais símbolos não podem ser utilizados. Os outros
identificadores, como nome de objetos, constantes e exceções,
seguem as mesmas regras.

Delimitadores
Um delimitador é um símbolo utilizado para representar operações
e expressões aritméticas. Podem ser simples ou compostos.

Delimitadores Simples
Símbolo Significado
+ Adição
% Indicador de atributo
‘ Delimitador de caracteres alfanuméricos
. Seletor de componente
/ Divisão
( Delimitador que abre lista ou expressão
) Delimitador que fecha lista ou expressão
: Indicador de variável do servidor
, Separador de item
* Multiplicação
“ Delimitador de identificador literal
= Operador relacional de igualdade
< Operador relacional de menor
> Operador relacional de maior
@ Indicador de acesso remoto ao banco de dados
; Indicador de fim de linha
- Subtração ou negação

Delimitadores compostos
Símbolo Significado
:= Operador de atribuição
=> Operador de associação
|| Concatenação de alfanuméricos
** Exponenciação
<< Delimitador de início de label
>> Delimitador de fim de label
/* Delimitador de início de comentário
*/ Delimitador de fim de comentário
.. Operador de intervalo
<> Diferença
!= Diferença
~= Diferença
^= Diferença
<= Menor ou igual
>= Maior ou igual
-- Comentário de linha

9
Dados

Literais
Literal pode ser um número, caractere, cadeia de caracteres
(strings) ou valores booleanos. Os numéricos são representados
pela união de algarismos.
Caracteres e cadeias de caracteres estão sempre entre apóstrofes
(‘). Note que ao comparar valores que estão entre os apóstrofes, o
PL/SQL é sensível a caracteres maiúsculos e minúsculos. Assim,
‘abc’ é diferente de ‘ABC’.
Booleanos podem assumir os valores TRUE (verdadeiro) ou
FALSE (falso). Note que esses são valores e não cadeias de
caracteres, pois não estão entre apóstrofes.

Comentários
Os comentários em PL/SQL são de dois tipos:
a) Uma linha: utiliza-se o delimitador --. A partir dos dois hífens
tudo o que for escrito até o final da linha é considerado
comentário.
Exemplo
nVar number; -- isto é um comentário de linha
b) Múltiplas linhas: utiliza-se o delimitador /* para abrir e */ para
fechar. Tudo e todas as linhas que estiverem entre os dois
delimitadores serão ignorados pelo compilador.
Exemplo
/* aqui começa um comentário
que pode conter várias linhas
até aqui */

Tipos de dados
Toda constante e variável devem conter um tipo de dado. O tipo
de dado especifica a forma de armazenamento e tamanho das
variáveis. Há quatro tipos básicos: escalar (os mais comuns),
compostos (contêm componentes associados), referenciados
(contêm ponteiros de memória), LOB (utilizados para armazenar
objetos muito grandes).
Estes são os tipos de dados escalares:
Tipo de dado Descrição
BINARY_INTEGER Inteiros com sinal. Varia de -2147483647 a.
2147483647. Ocupa pouco espaço, mas é mais lento
que PLS_INTEGER.
NUMBER Admite número de ponto fixo e flutuante. Varia de 1E-
130 até 10E125. Maior precisão: 38 dígitos.
PLS_INTEGER Inteiros com sinal. Varia de -2147483647 a.
2147483647. Ocupa menos espaço que NUMBER.
LONG Dados alfanuméricos de tamanho variável até 32767
bytes. Colunas do tipo LONG podem conter até 2Gb.
LONG RAW Idêntico ao LONG, porém para armazenar dados
binários.
NCHAR Idêntico ao CHAR, porém para armazenar caracteres
do tipo NLS.

10
 Dados
NVARCHAR2 Idêntico ao VARCHAR2, porém para armazenar
caracteres do tipo NLS.
RAW Utilizado para armazenar dados binários ou byte
strings. Limitado a 32.727 bytes.
ROWID Toda tabela possui esta coluna que indica o endereço
de armazenamento da linha.
STRING Idêntico ao VARCHAR2.
UROWID Indica o endereço de armazenamento da linha da
tabela.
VARCHAR2 Dados alfanuméricos de tamanho variável até 32.737
bytes. Colunas em tabelas armazenam até 4.000
bytes.
BOOLEAN Assume valores TRUE, FALSE e NULL. Utilizado
apenas para operações lógicas.
DATE Utilizado para armazenar data e hora. Varia de 1 de
janeiro de 4712 a.C. até 31 de dezembro de 9.999 d.C.
TIMESTAMP[(n)] Armazena dia, mês, ano, hora, minuto e segundo. O
parâmetro opcional n representa o número de dígitos
de precisão dos segundos e pode variar de 0 a 9.

Subtipos
São tipos de dados criados com base em outros.
NUMBER
Tipo de dado Descrição
DEC Utilizado para declarar variáveis de ponto fixo até 38
dígitos.
DECIMAL Utilizado para declarar variáveis de ponto fixo até 38
dígitos.
DOUBLE_PRECISION Utilizado para declarar variáveis de ponto flutuante
até 38 dígitos ou 126 dígitos binários.
FLOAT Utilizado para declarar variáveis de ponto flutuante
até 38 dígitos ou 126 dígitos binários.
INT Utilizado para declarar inteiros até 38 dígitos.
INTEGER Utilizado para declarar inteiros até 38 dígitos.
NUMERIC Utilizado para declarar variáveis de ponto fixo até 38
dígitos.
REAL Utilizado para declarar variáveis de ponto flutuante
até 18 dígitos ou 63 dígitos binários.
SMALLINT Utilizado para declarar inteiros até 38 dígitos.
BYNARY_INTEGER
Tipo de dado Descrição
NATURAL Aceita valores não-negativos.
NATURALN Aceita valores não-negativos e não admite valores
nulos.
POSITIVE Aceita valores positivos.
POSITIVEN Aceita valores positivos não-nulos.
SIGNTYPE Restringe valores a 0, 1 e –1.
VARCHAR2
Tipo de dado Descrição
VARCHAR Idêntico ao VARCHAR2.
CHAR Dados alfanuméricos de tamanho fixo até 32.767
bytes. O padrão é tamanho 1. Máximo em colunas de
tabelas é 2.000.
CHARACTER Idêntico ao CHAR.

11
Dados

TIMESTAMP
Tipo de dado Descrição
TIMESTAMP[(n)] WITH TIME ZONE
Acrescenta o horário local ao TIMESTAMP. Apresenta
a diferença de hora entre o horário de Greenwich e o
horário local.
TIMESTAMP[(n)] WITH LOCAL TIME ZONE
Igual ao anterior. A diferença básica é que não é
possível atribuir valores literais a este tipo de dado.
INTERVAL YEAR[(n)] TO MONTH
Armazena intervalos de anos e meses. O parâmetro
n indica a precisão para o ano.
INTERVAL DAY[(n)] TO SECOND[(m)]
Armazena intervalos de dias para segundos. O
parâmetro n indica a precisão para os dias e m indica
a precisão para segundos.

Manipulação de datas
Uma variável que tenha sido declarada como sendo do tipo DATE
armazenam valores chamados datetime. Uma variável pode ser
declarada com INTERVAL e neste caso conterá intervalos de
data. Veja na tabela a seguir os valores válidos para cada campo:
Campo Valores Intervalo
YEAR -4712 a 9999 Qualquer inteiro diferente de zero
MONTH 1 a 12 0 a 11
DAY 1 a 31 Qualquer inteiro diferente de zero
HOUR 0 a 23 0 a 23
MINUTE 0 a 59 0 a 59
SECOND 0 a 59.99... 0 a 59.99...
TIMEZONE_HOUR -12 a 14 não aplicável
TIMEZONE_MINUTE 0 a 59 não aplicável
TIMEZONE_REGION ver em V$TIMEZONE_NAMES
TIMEZONE_ABBR ver em V$TIMEZONE_NAMES
Operações com datas
É possível realizar expressões com Datas e Intervalos. O resultado
obedecerá a tabela seguinte:
Operando1 Operador Operando2 Resultado
DATETIME + INTERVAL DATETIME
DATETIME - INTERVAL DATETIME
INTERVAL + DATETIME DATETIME
DATETIME - DATETIME INTERVAL
INTERVAL + INTERVAL INTERVAL
INTERVAL - INTERVAL INTERVAL
INTERVAL * NUMERIC INTERVAL
NUMERIC * INTERVAL INTERVAL
INTERVAL / INTERVAL INTERVAL
Para evitar problemas em "truncar" datas em operações, considere
declarar as variáveis com os seguintes subtipos que utilizam a
maior precisão possível:
TIMESTAMP_UNCONSTRAINED
TIMESTAMP_TZ_UNCONSTRAINED
TIMESTAMP_LTZ_UNCONSTRAINED
YMINTERVAL_UNCONSTRAINED
DSINTERVAL_UNCONSTRAINED

12
 Dados

Subtipos definidos pelo usuário

O usuário pode definir um subtipo com base em outro tipo de dado
presente no Oracle. Note que, neste caso, não será criado um novo
tipo, mas sim uma variação de um tipo já existente. É como definir
um tipo de dado para uma situação específica. Fica claro que este
subtipo criado não estará disponível para todo banco de dados,
mas apenas naquele módulo.
SUBTYPE nome IS base[(limite)] [NOT NULL];
Parâmetro Descrição
nome Nome do subtipo criado.
base É o tipo de dado base (padrão) do Oracle.
limite Opcional, indica o tamanho máximo que o subtipo pode
assumir.

Conversão de dados
A conversão de dados no PL/SQL pode ser implícita, quando a
própria linguagem se encarrega de fazer a conversão, ou explícita,
quando o usuário força a conversão utilizando TO_CHAR,
TO_NUMBER, TO_DATE, etc. (veja o Guia de Referência
Oracle 9i SQL da Novatec Editora para maiores detalhes).
Naturalmente, procure sempre utilizar conversões explícitas para
garantir maior clareza de código e facilidade de manutenção. Note
que, apesar de fazer boa parte das conversões de valores, isso toma
mais tempo de processamento.
No caso específico de conversão de alfanuméricos em data, deve-
se, para que seja feita uma conversão implícita com sucesso,
observar o formato padrão de data do banco de dados. Quando a
instalação do banco de dados é realizada em português do Brasil,
o formato será 'DD/MM/YYYY', mas se for instalado em inglês
será 'DD-MON-YY'.

Declarações
Para utilizar variáveis e constantes em seu programa, você deve
declará-los anteriormente. Isso serve para alocar espaço de memória
e especificar o tipo de dado. A seção em que se declara variáveis
é a DECLARE, presente em blocos, subprogramas e pacotes.
Exemplo
DECLARE
dDtVenda Date;
nVlVenda Number(16,2);
cNmVendedor Varchar2(40);
nMultiplic CONSTANT NUMBER := 100;
Foram declaradas três variáveis e uma constante: dDtVenda do
tipo Data, nVlVenda do tipo numérico tamanho 16 e 2 casas
decimais, cNmVendedor do tipo alfanumérico de tamanho variável
até 40 caracteres e a constante nMultiplic do tipo numérica com
valor 100.

13
Dados

DEFAULT
Utilize a palavra-chave DEFAULT e/ou o operador de atribuição
(:=) para especificar valores-padrão para variável, constante ou
parâmetro de subprograma. Basta indicar o valor após o tipo de
dado e após uma das duas construções.

CONSTANT
Para declarar uma constante, utilize a palavra-chave CONSTANT
após o nome da constante e antes do tipo de dado.

NOT NULL
Pode-se utilizar, também, a palavra-chave NOT NULL para
especificar valores que não podem assumir valores nulos (lembre-
se de que todas as variáveis e conteúdos de campos não-inicializados
têm valor nulo atribuído pelo Oracle). Contudo, caso você utilize
NOT NULL para declarar uma variável, lembre-se de atribuir um
valor a ela já na sua declaração.

%TYPE
Permite declarar variáveis indicando o tipo de dado e o tamanho
de outras variáveis ou de colunas de tabelas do Banco de Dados.
Isso se faz utilizando %TYPE.
Exemplo
DECLARE
dDtEntrada dDtVenda%type;
cNmEmpresa empresa.NmEmpresa%type;
dDtVenda foi declarado anteriormente como sendo do tipo Data.
Assim dDtEntrada também será do mesmo tipo. cNmEmpresa
será declarado do mesmo tipo de dados do campo NmEmpresa da
tabela Empresa (note a forma: tabela.coluna).

%ROWTYPE
Permite declarar variáveis cujo conteúdo seja de toda uma linha de
uma tabela, cursor ou visualização (view).
Exemplo
DECLARE
rEmpresa empresa%rowtype;
rEmpresa será uma variável indexada com todas as colunas da
tabela empresa. Nesse exemplo, para acessar o conteúdo das
colunas, utiliza-se rEmpresa.NmEmpresa.

14
 Dados

Escopo e visibilidade
As variáveis declaradas em um bloco serão visíveis apenas nesse
bloco ou nos blocos localizados abaixo do bloco principal.
Contudo, é possível declarar uma variável com mesmo nome em
um bloco localizado abaixo do bloco principal. Nesse caso, o valor
da variável será o definido no bloco em que foi criado. Ao retornar
ao bloco anterior, o valor da variável não terá sofrido eventuais
alterações efetuadas no bloco inferior.
Exemplo
DECLARE
X NUMBER := 2;
Y NUMBER := 5;
BEGIN
... (1)
DECLARE
Y NUMBER := 1;
BEGIN
... (2)
END;
... (3)
END;
X e Y foram declaradas no primeiro bloco e serão visíveis em ...(1)
com seus respectivos valores. X também será visível em ...(2) com
o mesmo valor, mas Y foi redefinido no bloco mais abaixo, logo
terá seu valor alterado para a nova definição. Ao ir a ...(3), X
continuará com o mesmo valor, mas Y terá seu valor retornado ao
que era antes de entrar no segundo bloco.

Expressões e comparações
As operações em PL/SQL são realizadas em determinada ordem.
A seguir está a lista de precedência utilizada pelo PL/SQL.
Operador Operação
**,NOT Exponenciação, negação lógica.
+, - Afirmação, negação.
*, / Multiplicação, divisão.
+, -, || Adição, subtração e concatenação.
=, <, >, <=, >=, <>, !=, ~=, ^=, IS NULL, LIKE, BETWEEN, IN
Comparação.
AND E lógico.
OR Ou lógico.
Além dos operadores relacionais definidos anteriormente em
"Delimitadores", temos os seguintes:
Operador Sintaxe Operação
IS NULL x IS NULL Testa se um valor, variável ou constante é
nulo
LIKE x LIKE ‘A%’ Compara com base em padrões. Use %
para substituir todos caracteres a partir dali
e _ para substituir apenas 1 caractere
BETWEEN x AND y Testa se um valor está entre x e y
IN ( lista ) x IN (lista) Testa se um valor está presente na lista
|| x || ‘string’ Concatena alfanuméricos

15