Banco de Dados Objeto-Relacionais em Oracle

Bancos de Dados
Objeto-Relacionais em Oracle
Cristhiane Xavier Figueiredo

Juliana de Fátima Franciscani
Olinda Nogueira Paes Cardoso
{kristhy, jufafran, olinda}@comp.ufla.br
V SECICOM
Semana de Ciência da Computação
Departamento de Ciência da Computação
Universidade Federal de Lavras
Abril de 2003
Bancos de Dados Objeto-Relacionais em Oracle
ÍNDICE
1 Introdução....................................................................................................................... 2
2 BD Relacional, Orientado a Objeto e Objeto-Relacional............................................... 2
2.1 A tecnologia de BD Objeto Relacionais................................................................. 3
2.2 Alguns conceitos básicos de Orientação a Objetos ................................................ 4
2.3 Características Objeto-Relacionais no Oracle ........................................................ 5
2.3.1 Representação de Atributos Multivalorados pela Utilização do VARRAY... 5
2.3.2 Utilização de Tabelas Aninhadas para Representar Objetos Complexos....... 6
3 SQL*Plus........................................................................................................................ 7
3.1 SQL e Oracle .......................................................................................................... 7
3.2 SQL*Plus Worksheet ............................................................................................. 8
4 DBA Studio .................................................................................................................... 9
5 Oracle e a Tecnologia Objeto Relacional ..................................................................... 13
5.1 O que é um banco de dados objeto-relacional? .................................................... 13
5.1.1 Tipo de Objeto .............................................................................................. 13
5.1.2 Referência..................................................................................................... 14
5.1.3 Coleções: Tipo de Tabela e Vetor ................................................................ 14
6 PL/SQL......................................................................................................................... 15
6.1 Objetos Armazenados........................................................................................... 15
6.1.1 Funções / Procedimentos Armazenados ....................................................... 15
6.1.2 Pacotes .......................................................................................................... 16
6.1.3 Gatilhos......................................................................................................... 16
6.2 Características da PL/SQL ................................................................................... 17
6.2.1 Conjunto de caracteres.................................................................................. 17
6.2.2 Variáveis....................................................................................................... 17
6.2.3 Palavras reservadas....................................................................................... 17
6.2.4 Tipos de dados comuns ................................................................................ 18
6.2.5 Estrutura de blocos ....................................................................................... 18
6.2.6 Estruturas de controle ................................................................................... 18
6.2.7 Exceções ....................................................................................................... 19
7 Uma Aplicação ............................................................................................................. 19
7.1 Criação do banco de dados ................................................................................... 20
7.1.1 Criação de tipos de array .............................................................................. 24
7.1.2 Criação dos demais tipos de objeto .............................................................. 25
7.1.3 Criação de tabelas......................................................................................... 27
7.2 Inserção de dados nas tabelas ............................................................................... 30
7.2.1 Inserção de dados na tabela de Clientes ....................................................... 30
7.2.2 Inserção de dados na tabela de Artistas ........................................................ 31
7.2.3 Inserção de dados na tabela de CDs ............................................................. 33
7.2.4 Inserção de dados na tabela de CDs ............................................................. 33
7.2.5 Inserção de dados na tabela de Vendas ........................................................ 36
7.3 Alterações de dados das tabelas............................................................................ 37
7.4 Remoção de dados das tabelas ............................................................................. 41
7.5 Consultas .............................................................................................................. 44
8 Referências ................................................................................................................... 49
1
1 Introdução
Banco de Dados (BD) é uma das áreas da ciência da computação de maior destaque,
atualmente. A grande maioria dos sistemas computacionais existentes necessita manipular e
gerenciar dados, usando algum Sistema Gerenciador de Bancos de Dados (SGBD). Dentre
os modelos de dados usados nos SGBD, o modelo relacional há anos domina o mercado,
devido principalmente a sua simplicidade.
Nos últimos anos, a tecnologia de BD tem evoluído de diversas formas, uma delas
através da expansão da capacidade de manipular dados complexos, utilizando conceitos da
tecnologia de Orientação a Objetos (OO). Desta forma, surgiu o SGBD Objeto-Relacional
(SGBDO-R), que mantêm as vantagens do modelo relacional e acrescentam características
de OO. Este novo SGBDO-R, é uma ferramenta de gerenciamento de dados muito mais
poderosa que as tradicionais.
A Oracle Corporation é uma das maiores empresas da atualidade na criação de
sistemas de BD. Um de seus principais produtos é o Oracle Database, um SGBDO-R
muito utilizado nos maiores BD de empresas por todo o mundo. O objetivo deste curso é
apresentar os principais conceitos de BD objeto-relacional e suas vantagens, assim como
apresentar as ferramentas do Oracle Database e a linguagem PL/SQL, mostrando como
utilizá-las na criação e gerenciamento destes bancos de dados. Este curso é destinado a
pessoas que já possuem conhecimento na área de bancos de dados.
2 BD Relacional, Orientado a Objeto e Objeto-Relacional

Modelos e sistemas de dados convencionais, como o sistema relacional, de rede e
hierárquico, vêm sendo muito bem-sucedidos no que diz respeito ao desenvolvimento da
tecnologia de banco de dados, e são suficientes para muitas aplicações convencionais de
bancos de dados comerciais. Entretanto, eles apresentam algumas deficiências quando
aplicações de bancos de dados mais complexas precisam ser projetadas e implementadas.
Essas aplicações mais recentes possuem requisitos e características que diferem das
aplicações empresariais convencionais, incluindo estruturas mais complexas para os dados,
transações de longa duração, novos tipos de dados para armazenar imagens ou grandes itens
2
de texto, bem como em relação à necessidade de definir operações específicas de aplicações

não-padronizadas.
Os SGBD orientados a objetos foram propostos para fazer face às necessidades
dessas aplicações mais complexas. O método de orientação a objeto oferece a flexibilidade
para lidar com algumas exigências, sem ser limitado pelos tipos de dados e linguagens de
consulta disponíveis em sistemas de bancos convencionais. Os bancos de dados puramente
OO sofreram resistência do mercado devido a grande dificuldade de se fazer a mudança
entre o modelo relacional, que domina a maioria das aplicações já desenvolvidas, e este
novo modelo. Apesar de ser uma forma de atender às novas necessidades do mercado, esta
tecnologia não alcançou espaço suficiente, tendo que ser modificada.
Os SGBD objeto-relacionais surgiram como uma maneira de se estenderem as
características do modelo relacional, que é bastante limitado porém extremamente utilizado,
com algumas das características que apareceram em orientação a objetos. Ou, por outro
lado, acrescentar aos bancos de dados puramente OO as características do modelo
relacional e com isto ganhar mais espaço no mercado.
2.1 A tecnologia de BD Objeto Relacionais

As principais motivações existentes por trás do desenvolvimento de SGBDO-R têm
origem na incapacidade dos SGBD relacionais básicos de fazer face aos desafios de novas
aplicações. Elas se encontram basicamente em áreas que envolvem vários tipos de dados,
por exemplo, textos na edição informatizada em desktops; imagens obtidas por satélite ou
na previsão do tempo; dados complexos não-convencionais em projeto de engenharia, em
informações sobre o genoma biológico, e em projetos de arquitetura; dados de séries
temporais no histórico das transações do mercado de capitais ou no histórico de vendas; e
dados sobre o espaço e os acidentes geográficos na confecção de mapas; dados sobre a
poluição da água e do ar, além de dados sobre o tráfico. Portanto, existe uma clara
necessidade de se projetarem Bancos de Dados que possam desenvolver, manipular e
manter os objetos complexos que surgem de tais aplicações. Além disso, torna-se
necessário lidar com informações digitalizadas que representam streams (correntes) de
dados de áudio e vídeo (particionadas em estruturas individuais) que requerem o
armazenamento de BLOB’s (grandes objetos binários) nos SGBD.
3
A boa aceitação do modelo relacional é ajudada por uma infra-estrutura muito

sólida em termos dos SGBD comerciais que foram projetados para suportá-la. Entretanto, o
modelo relacional básico e versões anteriores de sua linguagem SQL mostraram
inadequados para enfrentar os citados desafios, e não têm conceito como identidade de
objeto, herança, encapsulamento ou suporte para múltiplos tipos de dados e objetos
complexos. Por conseguinte, surgiu uma tendência de combinar as melhores características
do modelo e da linguagem de dados de objetos com o modelo de dados relacional, de modo
que o mesmo possa ser estendido para lidar com as desafiadoras aplicações atuais.
2.2 Alguns conceitos básicos de Orientação a Objetos
Alguns conceitos da orientação a objetos foram acrescentados à tecnologia de

bancos de dados relacionais e serão apresentados a seguir.
• Identidade de Objeto: Objetos possuem identidades únicas que são independentes
de seus valores de atributos.
• Construtores de Tipos: Estruturas de objetos complexas podem ser construídas
através da aplicação recursiva de um conjunto de construtores básicos, tais como
tuplas, set (conjunto), list (lista), e bag.
• Encapsulamento de operações: A estrutura do objeto e as operações que podem
ser aplicadas a objetos estão incluídas nas definições de classe do objeto.
• Compatibilidade da linguagem de programação: Tanto objetos persistentes
quanto transientes são tratados uniformemente. Os objetos são tornados
persistentes, anexando-os a uma coleção persistente.
• Hierarquias e herança de tipo: Tipos de objetos podem ser especificados
utilizando uma hierarquia de tipo, que permite a herança tanto de atributos quanto
de métodos de tipos previamente definidos.
• Extensão: Todos os objetos persistentes de um tipo particular podem ser
armazenados em uma extensão. As extensões correspondem a uma hierarquia de
tipo com restrições set/subset reforçadas.
• Suporte para objetos complexos: Tanto objetos complexos estruturados como
não-estruturados podem ser armazenados e manipulados.
4
• Polimorfismo e sobrecarga do operador: Nomes de métodos e operações podem

ser sobrecarregados para serem aplicados a diferentes tipos de objetos com
diferentes implementações.
• Versão: Alguns sistemas OO oferecem suporte para manutenção de várias versões
do mesmo objeto.
2.3 Características Objeto-Relacionais no Oracle
O Oracle é um bom exemplo de SGBDO-R. Ele continua a prover as

funcionalidades de um SGBD relacional e, além disso, suporta conceitos de orientação a
objetos. Isso fornece níveis mais elevados de abstração, de modo que os desenvolvedores
de aplicações podem manipular objetos da aplicação, em vez de construir os objetos a partir
de dados relacionais. As informações complexas sobre um objeto podem ser escondidas,
mas as propriedades (atributos, relacionamentos) e os métodos (operações) do objeto
podem ser identificados no modelo de dados. Além disso, declarações de tipo de objeto
podem ser reutilizadas através de herança, reduzindo-se o tempo e o trabalho para o
desenvolvimento da aplicação.
Alguns exemplos serão apresentados a seguir, apenas para mostrar como algumas
características de OO foram acrescentadas e como alguns conceitos mudaram no Oracle.
Um maior detalhamento deste tópico será feito no Capítulo 5.
2.3.1 Representação de Atributos Multivalorados pela Utilização do VARRAY
Alguns atributos de um objeto/entidade podem ser multivalorados. No modelo

relacional, os atributos multivalorados teriam que ser tratados formando-se uma nova
tabela. Se dez atributos de uma grande tabela forem multivalorados teremos onze tabelas
geradas a partir de uma única tabela após normalização. Para ter os dados de volta, o
desenvolvedor terá que realizar dez junções entre essas tabelas. Isso não acontece em um
modelo de objetos, uma vez que todos os atributos de um objeto, incluindo os
multivalorados, estão encapsulados dentro do objeto. O Oracle consegue isso utilizando um
tipo de dado array de extensão variável (VARRAY), que tem as seguintes propriedades:
COUNT: número corrente de elementos, e LIMIT: número máximo de elementos que o
VARRAY pode conter. Esse é definido pelo usuário.
5
Considere o exemplo de uma entidade VARRAY cliente com os atributos nome

e numero_telefone, na qual numero_telefone é multivalorado. Primeiramente
precisamos definir um tipo de objeto que representa um numero_telefone:
CREATE TYPE tipo_num_telefone AS OBJECT (numero_telefone CHAR (10));
Em seguida, definimos um VARRAY cujos elementos seriam objetos do tipo
tipo_num_telefone:
CREATE TYPE tipo_lista_telefone AS VARRAY (5) OF tipo_num_telefone;
Agora podemos criar o tipo de dado tipo_cliente como um objeto com os

atributos nome_cliente e números_telefone:
CREATE TYPE tipo_cliente AS OBJECT (
nome_cliente VARCHAR (20),
numero_telefone tipo_lista_telefone);
Agora é possível criar a tabela cliente como: CREATE TABLE clientes OF tipo_cliente;
Para recuperar uma lista de todos os clientes e seus números de telefone, podemos
emitir uma consulta simples sem quaisquer junções:
SELECT nome_cliente, números_telefone FROM clientes;
2.3.2 Utilização de Tabelas Aninhadas para Representar Objetos Complexos
Na modelagem de objetos, alguns atributos de um objeto poderiam ser eles próprios

objetos. O Oracle consegue isso possuindo tabelas aninhadas. Aqui, colunas (equivalentes
a atributos de objetos) podem ser declaradas como tabelas. Utilizando o exemplo anterior,
vamos supor que tenhamos uma descrição anexada a cada número de telefone (por
exemplo, residencial, comercial, celular). Isso poderia ser modelado por meio de uma
tabela aninhada, primeiramente redefinindo tipo_num_telefone da seguinte maneira:
CREATE TYPE tipo_num_telefone AS OBJECT (
numero_telefone CHAR (10),
descrição CHAR (30));
Em seguida, redefinimos tipo_lista_telefone como uma tabela de

tipo_numero_telefone da seguinte maneira:
CREATE TYPE tipo_lista_telefone AS TABLE OF tipo_numero_telefone;
Podemos, então, criar o tipo chamado tipo_cliente e a tabela chamada cliente

como antes. A única diferença é que tipo_lista_telefone é agora uma tabela aninhada ao
6
invés de um VARRAY. Ambas as estruturas têm funções semelhantes, com algumas

diferenças. Tabelas aninhadas não têm um limite superior quanto ao número de itens,
enquanto VARRAYs têm um limite. Itens individuais podem ser recuperados de tabelas
aninhadas, mas isso não é possível com VARRAYs. Índices adicionais também podem ser
construídos em tabelas aninhadas para o acesso mais rápido aos dados.
3 SQL*Plus
SQL*Plus é a interface de definição e manipulação de dados no BD Relacional do
Oracle. A linguagem SQL (Strutured Query Language) é o padrão adotado por todos os
fornecedores de banco de dados relacionais. O SQL*Plus da Oracle é um superconjunto da
SQL padrão: ela obedece aos padrões de uma linguagem compatível com SQL e possui
alguns acessórios específicos para o Oracle. Antigamente, o SQL*Plus se chamava UFI, a
interface amigável com o usuário.
3.1 SQL e Oracle
O Oracle Server interpreta apenas instruções em SQL – quando ferramentas como o

Oracle Forms interagem com o BD, elas passam instruções SQL para processamento. A
implementação da Oracle de SQL através do SQL*Plus é compatível com os padrões ANSI
(American National Standards Institute) e ISSO (International Standards Organization).
Quase todas as ferramentas Oracle oferecem suporte idêntico à sintaxe SQL. A Figura 1
mostra a interface do SQL*Plus.
Figura 1: SQL*Plus.
7
O SQL é personalizado para aproveitar a simplicidade do modelo relacional. Como

os dados são armazenados através de relações, é possível trabalhar em conjuntos, em
oposição às linhas de dados independentes. Com o SQL*Plus, grande parte do trabalho
associado à recuperação de dados fora de um BD tradicional, não relacional, desaparece.
Por exemplo, você não lê mais “registros”, em vez disso, você escreve um programa que
trata com todos os registros associados a uma entidade (relação).
No SQL*Plus, qualquer ação que você decida adotar é realizada como um conjunto
completo.
Resumindo:
• Na interface SQL*Plus programa-se usando uma linguagem compatível a SQL. “Plus” se
refere às inclusões da Oracle na linguagem SQL;
• Todo o trabalho com um BD relacional é feito com uma linguagem de programação
baseada em SQL;
• A SQL*Plus é amigável para o usuário;
• Ao programar na SQL*Plus, trabalha-se em conjuntos, ou relações, de dados (isto é, as
informações não são processadas num registro por vez).
3.2 SQL*Plus Worksheet

A interface SQL*Plus Worksheet é uma das formas do DBA interagir com o banco
de dados, de forma parecida com o uso do próprio SQL*Plus. É possível também executar
scripts no SQL*Plus Worksheet. Ele mantém um histórico dos comandos que foram
executados, com isso pode-se facilmente relembrar e executar novamente comandos
anteriores. A Figura 2 mostra a interface do SQL*Plus Worksheet.
Figura 2: O SQL*Plus Worksheet.
8
Nota importante: O SQL*Plus Worksheet fornece uma interface mais amigável entre o
usuário e o SQL*Plus. Dessa forma, o SQL*Plus deve ser instalado para se poder utilizar o
SQL*Plus Worksheet. O SQL*Plus Worksheet no Oracle Enterprise Manager pode ser
usado para muitas atividades que são realizadas no SQL*Plus. Entretanto, a maioria dos
comandos de formatação só funciona no SQL*Plus.
4 DBA Studio
O DBA Studio é uma ferramenta integrada que permite ao usuário administrar num
único ambiente, instâncias, esquemas, segurança e armazenamento do banco de dados, com
uma visão unificada em forma de árvore. Por causa deste acesso unificado a funções de
administração, a troca entre as diversas tarefas do DBA é fácil e isso proporciona uma
melhor visão do estado e da configuração do BD.
Ao iniciar os uso desta ferramenta a tela apresentada na Figura 3 aparecerá, onde
você deve optar por executar o “DBA Studio standalone”.
Figura 3: Tela inicial do DBA Studio.
A Figura 4 apresenta a tela de login do DBA Studio, onde o usuário deve se

identificar através de seu nome e senha, informando também o nome do banco de dados no
qual deseja trabalhar, para que seja feita sua conexão.
9
Figura 4: Tela de login no DBA Studio.
Nessa tela, o usuário tem a opção de se conectar como um usuário “Normal”, ou

como “SYSDBA” (administrador do sistema), ou ainda como “SYSOPER” (operador do
sistema), caso este possua os privilégios suficientes. A tela principal do DBA Studio é
apresentada na Figura 5.
Figura 5: Tela principal do DBA Studio.
10
Com o gerenciador de armazenamento do DBA Studio é possível administrar

tablespaces, segmentos de rollback, arquivos de dados e logs de redo. Também é possível
visualizar controles de arquivos e seus atributos, assim como enxergar uma lista de todos os
arquivos de log do sistema.
Para este curso foi criado um tablespace chamado “secicom” que deverá armazenar
todos os dados referentes às tabelas criadas no BD criado para o curso
“secicom.comp.ufla.br”. Para criá-lo, basta habilitar as opções de criação, clicando com o
botão direito do mouse, sobre a palavra “Tablespaces”. A Figura 6 apresenta a tela
referente aos arquivos de controle deste tablespace.
Nota importante: Para maiores informações sobre o funcionamento do DBA Studio,
utilize o documento de ajuda que pode ser acessado no “Quick Tour”.
Figura 6: Gerenciador de armazenamento do DBA Studio.
O gerenciamento de instâncias do DBA Studio permite que o usuário dê um startup

ou um shutdown num BD; visualize e edite valores de parâmetros de inicialização;
enxergue a sessão do SQL corrente e seu plano de execução; gerencie configurações
armazenadas; gerencie recursos de CPU e paralelismo no BD; gerencie sessões dos
usuários; e monitore operações de execução extensa.
11
Com relação ao gerenciamento de esquemas, o DBA Studio permite ao usuário

criar, alterar, ou remover objetos no BD, tais como: clusters, índices, tabelas, visões, etc.
Operações destes tipos serão apresentados na seção 12 desta apostila, usando uma aplicação
como exemplo. A Figura 7 mostra a lista dos objetos que podem ser gerenciados.
Figura 7: Gerenciamento de esquemas no DBA Studio.
O gerenciamento de segurança do DBA Studio permite que administradores

autorizados criem, alterem e removam do BD usuários e perfis, além disso, concedam ou
revoguem autorizações e privilégios destes.
Figura 8: Gerenciamento de segurança no DBA Studio.
12
5 Oracle e a Tecnologia Objeto Relacional

O Oracle possibilita ao usuário a definição de diferentes tipos de dados, desta forma
é possível manipular dados complexos, tais como dados multivalorados ou compostos e
objetos longos, como imagens, vídeos, som. Esta versão do Oracle também permite a
implementação das principais características de orientação a objetos como identidade de
objeto, encapsulamento, polimorfismo, métodos, mensagens e herança.
5.1 O que é um banco de dados objeto-relacional?

A versão 8 do Oracle foi a primeira a incorporar a um banco de dados relacional, a
tecnologia orientada a objetos, ou seja, o Oracle8 foi o primeiro SGBD objeto-relacional.
Sendo assim, ele nem pode ser considerado puramente orientado a objetos, nem tampouco
apenas relacional. Isto implica que todas as características relacionais permanecem, e além
destas foram acrescentadas outras, em outras palavras, as tabelas continuam a existir,
porém estas estão menos limitadas.
As tabelas, anteriormente, apenas podiam conter valores atômicos em seus atributos,
agora podemos definir novos tipos de dados e usá-los para receber valores complexos. O
Oracle8 permite que os usuários criem novos tipos de objetos, novos tipos de tabelas,
referências para objetos, dentre outros. A seguir será apresentada uma definição
simplificada de cada um desses novos tipos.
5.1.1 Tipo de Objeto
Um tipo de objeto define a estrutura de um objeto (object), que armazena dados

estruturados, por exemplo, da seguinte forma: um objeto chamado ENDERECO pode ser
formado pelos tipos básicos “end”, “cidade”, “estado” e “cep”, que por sua vez, podem
conter valores alfanuméricos. Uma vantagem de dividir um atributo endereço desta forma,
é que consultas a partes deste são mais fáceis, como, por exemplo, selecionar dados de uma
determinada cidade. De outra forma, caso o endereço fosse um conjunto único de
caracteres, teríamos que repartir o endereço para identificar a cidade.
Outra grande vantagem é que agora é possível usar este tipo criado pelo usuário
como tipo de um atributo em uma tabela ou em outro objeto, como, por exemplo,
poderíamos ter um objeto chamado CLIENTE composto, dentre outros, por “nome”, “cpf”,
13
“endereco”, onde este último poderia ser do tipo ENDERECO. Uma tabela de clientes
poderia ser criada a partir deste objeto CLIENTE.
Criando tipo de objeto: create type nome_objeto as object (atributos);
5.1.2 Referência
Um atributo pode ser declarado como uma referência (ref) para um tipo de dado
construído por um usuário. Isto só é possível pela característica de que cada objeto possui
um identificador único, chamado de Object Identificator (OId). A referência aponta para o
OId de um objeto, mesmo que este esteja armazenado em outro local.
Criando referência: create type nome_referência as ref of nome_objeto;
5.1.3 Coleções: Tipo de Tabela e Vetor
Um tipo de tabela (table type) define uma coleção de dados de um tipo de objeto
que já tenha sido criado. Por exemplo, para a tabela de clientes poderíamos criar a opção
destes possuírem vários endereços cadastrados, assim o atributo “endereco” não seria mais
definido como do tipo de objeto ENDERECO, e sim como uma tabela formada por este
tipo, ou em outras palavras, como um conjunto de endereços.
Criando tipo de tabela: create type nome_tipo as table of nome_objeto;
Sempre que usamos um tipo de tabela como tipo de atributo de uma tabela, estamos
colocando uma tabela dentro de outra, ou seja, estamos criando uma tabela aninhada
(nested table). No SGBD precisa ser definido um nome para que esta tabela seja
armazenada.
Criando tabela com tabela aninhada:
create table nome_tabela of nome_objeto (...)
nested table nome_atributo stores as nome_tab_aninhada;
Outra forma de criar coleções de dados é através de vetores de tamanhos fixos
(array) ou variados (varray). A principal diferença entre estes e o tipo de tabela, é que estes
vetores são ordenados, porém possuem um limite máximo predefinido de elementos do
conjunto. No caso dos clientes poderíamos, por exemplo, definir o número máximo de
endereços para cada cliente e usar um vetor em vez de um tipo de tabela.
Criando varray: create type nome_tipo as varray(max) of tipo_de_dado;
14
Além destas diferenças, estes dois tipos diferem também na forma de acesso aos
dados, como veremos em exemplos posteriormente, e na forma de armazenamento dos
dados, pois dados de tipos de tabelas são armazenados separadamente das tabelas, já que
não há previsão de seu tamanho máximo.
6 PL/SQL
A partir da versão 6 do Oracle, foi implementada uma linguagem procedural
chamada PL/SQL, que alia construtores comuns em linguagens de programação à
linguagem de consulta SQL, utilizada na maioria dos BDs. Ou seja, é uma linguagem de
manipulação de dados, onde é possível construir estruturas condicionais, estruturas de
repetição, etc.
A PL/SQL pode ser usada em diversas interfaces do Oracle, tanto para gerenciar
bancos de dados, como também em ferramentas de desenvolvimento de projetos e
aplicações. Aqui estaremos tratando da PL/SQL de banco de dados, onde funções e
procedimentos podem ser criados e armazenados, utilizando esta linguagem.
6.1 Objetos Armazenados

Um objeto armazenado é um segmento de código PL/SQL salvo no banco de dados.
Estes objetos podem ser: funções, procedimentos, pacotes e gatilhos do banco de dados.
6.1.1 Funções / Procedimentos Armazenados
Procedimento ou função armazenada (stored procedure) é um código associado a

um ou mais elementos do banco de dados, que podem ser executados a partir de programas
criados para uma aplicação, ou a partir das interfaces do Oracle. A diferença deste para um
procedimento não armazenado, é que este é também gerenciado pelo SGBD, aumentando a
carga de trabalho do mesmo.
A vantagem do uso deste tipo de procedimento é a diminuição da carga de trabalho
do programador, porém se ocorrerem em grande quantidade num banco de dados pode
comprometer o seu desempenho. O ideal é que se faça um estudo da necessidade de se criar
estes procedimentos, levantando as prioridades da aplicação.
15
Os procedimentos e as funções podem ou não receber parâmetros de entrada e saída.

A principal diferença entre eles é que uma função deve sempre retornar algum valor de
saída.
Criando procedimento ou função:
create [or replace] procedure nome_procedimento [(parâmetros)] as
begin corpo_procedimento end;
ou
create [or replace] function nome_função [(parâmetros)] return tipo_dado as
begin corpo_função end;
6.1.2 Pacotes
Um pacote é um conjunto de procedimentos e funções empacotados, normalmente

devido à funcionalidade semelhante. Todos os procedimentos e funções internas são
gravados no dicionário de dados como um único pacote armazenado.
6.1.3 Gatilhos
Um gatilho (trigger) é um procedimento que é associado a uma tabela do banco de

dados, e que é executado quando algum evento acontece. O principal motivo para se usar
gatilhos é para a validação de alguns dados antes que eles sejam gravados no banco de
dados. Os tipos de ações incluem inserções, remoções e alterações de dados. Com os
gatilhos é possível:
• Verificar dados antes que eles sejam enviados para o banco de dados.
• Gerar registros em outras tabelas com base nos dados que acabaram de ser introduzidos.
• Implementar regras.
• Uma vez criado, o gatilho associado a tabela não irá precisar da intervenção do usuário
para serem executados, estes são disparados automaticamente. É essa a idéia que dá nome
ao componente de gatilho.
Criando gatilho: create [or replace] trigger nome_gatilho
{before | after |instead of} {insert | update | delete}
on nome_tabela begin corpo_gatilho end;
16
6.2 Características da PL/SQL

Assim como todas as linguagens de programação, a PL/SQL possui um conjunto de
conceitos introdutórios a serem apresentados para construção de programas.
6.2.1 Conjunto de caracteres
O programador está limitado aos seguintes caracteres:

• Todas as letras maiúsculas e minúsculas
• Dígitos de 0 a 9
• Símbolos ( ) + - * / < > = ! ~ ^, ; : . ‘ “ @ % # $ & _ | { } ? [ ]
Alguns destes símbolos servem para código, outros servem como operadores
aritméticos e relacionais.
6.2.2 Variáveis
As regras para a definição das variáveis são:

• As variáveis devem começar com uma letra
• Podem, opcionalmente, ser seguidas de uma ou mais letras, números ou os caracteres
especiais $, # ou _
• As variáveis não podem Ter mais que 30 caracteres
• Não podem existir espaços incorporados no nome da variável
Uma variável deve ser declarada no início dos procedimentos, da seguinte forma:
declare codcli number;
nomecli varchar2(40);
6.2.3 Palavras reservadas
Como em outras linguagens de programação, palavras reservadas não podem ser

utilizadas como nome de variáveis. Os tipos de dados criados pelo usuário, também são
considerados palavras reservadas. Uma lista completa das palavras reservadas da PL/SQL
pode ser encontrada no conjunto de documentação da Oracle.
17
6.2.4 Tipos de dados comuns
Os tipos de dados básicos comuns a linguagem PL/SQL são:

• varchar2(n) – valores alfanuméricos de tamanho variável “n” (até 32.767 bytes)
• number(p,e) – todos os dados numéricos, onde p é a precisão (1 a 38 caracteres) e e é a
escala, que é o número de caracteres depois da vírgula
• date – valores de datas de comprimento fixo (formato dd-mm-aa)
• boolean – contém os status true ou false
6.2.5 Estrutura de blocos
Os programas da PL/SQL são escritos em blocos, que podem ou não possuir nome.
Caso o bloco seja armazenado, por exemplo como uma função, após a o tipo do bloco
podem ser colocados argumentos de entrada (in), de saída (out) ou de entrada e saída (in
out). As seções declare (para declaração de variáveis) e exception (uma parte do bloco só
é executado em caso de erro ou exceção) são opcionais. Os blocos podem ser aninhados,
criando diversos blocos de código dentro do principal, para isso usamos os limitadores
begin e end.
6.2.6 Estruturas de controle
As estruturas de controle da PL/SQL são: o controle de programa, três tipos de

estrutura condicional e quatro tipos de estruturas de repetição. O controle de programa é
responsável por manter o status das variáveis que ele utiliza. As três variações possíveis
para a estrutura condicional são:
if – then – end if;
if – then – else – end if;
if – then – elsif – end if.
As quatro variações possíveis para a estrutura de repetição são:
loop – exit – end loop;
loop – exit when – end loop;
while – loop – end loop;
for – in x..y – loop – end loop.
18
6.2.7 Exceções
A seção exception é o método da PL/SQL para tratar de condições de erro, ou seja,

quando um erro ocorre durante a execução de uma seção de código, o controle vai
automaticamente para a execução do bloco da seção exception. Uma descrição completa
dos possíveis tipos de erros da PL/SQL pode ser encontrada na coleção de documentos da
Oracle. A seguir será apresentado um quadro com alguns dos erros mais comuns:
Exemplo de tratamento de erro num bloco de programa:

exception
when no_data_found then
raise_application_error (-20100,”Dado não encontrado”);
when dup_val_on_index then
raise_application_error (-00001,”Valor já cadastrado”);
Nota importante: a função “raise_application_error” modifica a mensagem de erro que

apareceria na tela de retorno para o usuário, trocando o nome do erro pela mensagem
informada.
7 Uma Aplicação
Um modelo de aplicação foi imaginado para servir de base aos exemplos utilizados
no curso. Estaremos implementando parte de um banco de dados para uma loja virtual de
CDs. A Figura 9 representa este BD.
19
Figura 9: Modelo relacional estendido para o BD de uma loja virtual de CDs.

Serão criadas quatro tabelas: CLIENTES, ARTISTAS, CDS e VENDAS. Algumas
observações podem ser feitas sobre alguns atributos complexos que estas tabelas possuem,
tais como:
• Na tabela CLIENTES o endereço é um tipo de dado composto e telefones é
multivalorado, de tamanho máximo determinado.
• Na tabela CDS o conjunto das músicas de um CD é composto e multivalorado, com
tamanho máximo indeterminado. Além disso, há uma lista para um conjunto de referências
para artistas deste CD.
• Na tabela ARTISTAS, há uma lista contendo as referências para os CDs gravados por
este.
• Na tabela VENDAS, há uma referência para os dados de um cliente que efetuou a compra
e uma tabela de referências para os CDs vendidos.
7.1 Criação do banco de dados

A criação dos elementos deste BD deve seguir uma ordem lógica, não podemos
criar o objeto CLIENTE, sem que antes tenhamos criado o objeto ENDERECO, por
exemplo. Sendo assim, a ordem em que forem apresentados os comandos de criação dos
objetos é importante e deve ser seguida.
20
Os comandos de criação dos objetos deste modelo, assim como os de qualquer outro
podem ser escritos em diversas interfaces, como SQL*Plus, SQL*Plus Worksheet, ou o
DBA Studio, como mostrado a seguir.
Figura 10: Criação do tipo de objeto ENDERECO usando o SQL*Plus.

Criação do tipo de objeto ENDERECO usando o DBA Studio. Para iniciar a criação
de um objeto, escolha a opção criar “Criar” no menu principal.
Figura 11: 1o passo - escolher a opção “Tipo de Objeto”.
21
Figura 12: 2o passo - definir o nome do objeto e “Adicionar” atributos.
Figura 13: 3o passo - definir o nome do atributo, o seu tipo de dados.

Nota importante: O 3o passo vai ser repetido para cada atributo.
22
Figura 14: 4o passo - depois de definir todos os atributos, “Criar” o tipo de objeto.
Uma vantagem do DBA Studio é que a qualquer momento pode-se visualizar a
sintaxe do comando que está sendo executado no BD. Para isso basta que seja marcada a
opção “Mostrar SQL”.
Figura 15: Mensagem que aparece quando a criação ocorre sem erros.
23
7.1.1 Criação de tipos de array
Neste modelo temos dois casos onde deverão ser criados tipos de array: um para o
atributo “tels_cli” contendo uma lista de telefones do cliente, e outro “mus_cd” contendo
uma lista com as músicas de um CD. Sendo que o último depende da criação anterior do
tipo de objeto MUSICA. Desta forma, os comandos para a criação destes tipos devem
anteceder a dos objetos que irão usá-los, como se segue:
Figura 16: Criação do tipo de objeto telefones.

A criação dos demais tipos de objeto segue os mesmos passos. A única diferença
que pode ocorrer é no caso de usar um tipo de objeto pré-defindo, pois para isso é
necessário informar o nome do esquema. Veja na Figura abaixo, um dos passos da criação
do tipo de objeto CLIENTE e observe o esquema escolhido para o tipo ENDERECO.
Figura 17: Tipo de dado construído pelo usuário.
24
7.1.2 Criação dos demais tipos de objeto
CLIENTE: SQL> create type cliente as object (

2 cpf_cli char(15),
3 nome_cli varchar2(40),
4 tels_cli telefones,
5 email_cli varchar2(40),
6 senha_cli char(8),
7 end_cli endereco);
MUSICA: SQL> create type musica as object (
2 num_mus smallint,
3 nome_mus varchar2(20),
4 letra_mus varchar2(200));
MUSICAS: SQL> create type musicas as varray (50) of musica;
O tipo ARTISTA deve ser criado temporariamente, como um tipo vazio, apenas
para ser referenciado no tipo de objeto CD. Posteriormente ele deverá ser redefinido.
ARTISTA: SQL> create type artista;
Os seguintes tipos a serem criados REFARTISTAS e REFCDS são interessantes,
pois são tipos de tabela compostos por referências aos tipos de objetos ARTISTA e CD,
respectivamente. O tipo REFCDS também será utilizado na tabela de VENDAS, para
representar o conjunto dos CDs vendidos a um cliente.
REFARTISTAS: SQL> create type refartistas as table of ref artista;
CD: SQL> create type cd as object (
2 cod_cd integer,
3 tit_cd varchar2(30),
4 preco_cd decimal(10,2),
5 qtd_cd integer,
6 art_cd refartistas,
7 mus_cd musicas);
REFCDS: SQL> create type refcds as table of ref cd;
ARTISTA: SQL> create or replace type artista as object (
2 cod_art integer,
25
3 nome_art varchar2(40),
4 tipo_art varchar2(20),
5 desc_art varchar2(100),
6 hp_art varchar2(40),
7 cds_art refcds);
VENDA: SQL> create type venda as object (
2 cod_ven integer,
3 data_ven date,
4 valor_ven decimal(10, 2),
5 pago_ven char(1),
6 cli_ven ref cliente,
7 cds_ven refcds);
A criação de referências no DBA Studio é tão simples como qualquer outra
operação, basta que no momento da criação do objeto, a opção “Objeto definido pelo
usuário será uma referência (REF)” seja habilitada, como mostrada na próxima Figura.
Figura 18: Criação de referência no DBAStudio.
26
7.1.3 Criação de tabelas
Uma vez criado o tipo de objeto, a criação das tabelas deste tipo se torna bem
simples. Neste momento deve-se informar que atributos são obrigatórios no banco de
dados, através da cláusula not null, bem como o(s) atributo(s) que formam a chave primária
(primary key).
No SQL*Plus o comando seria o seguinte:
Figura 19: Criação da tabela clientes no SQL*Plus.
Nota importante: No exemplo anterior, a tabela CLIENTES foi criada com todos os
atributos descritos no tipo de objeto CLIENTE, apesar de termos colocado no comando os
atributos que estão sendo modificados.
No DBA Studio, uma vez escolhida a opção criar Tabela, basta colocar seu nome, e
marcar a opção “Tabela de Objeto”. Aparecerá a opção de escolha para o esquema e para o
tipo de objeto. Depois de selecionado o objeto é possível determinar os atributos
obrigatórios, desmarcando a opção “Nulo”.
27
Figura 20: Criação da tabela clientes no DBAStudio.

Para determinar a chave primária, deve-se passar para a tela de “Restrições”,
escolher o tipo de restrição primary e informar que atributo(s) faz(em) parte da chave
primária.
Figura 21: Criação de chave primária no DBAStudio.
28
Figura 22: Mensagem que aparece quando a criação ocorre sem erros.
Por fim, será apresentado o código referente à criação das últimas tabelas deste
modelo de banco de dados. Observe que estas tabelas possuem tabelas aninhadas (nested
table), e estas devem receber nomes para serem armazenadas no BD. Em outras palavras,
teremos nas tabelas de CDS, ARTISTAS e VENDAS, tabelas aninhadas de referências para
os artistas e CDs.
CDS: SQL> create table cds of cd (
2 cod_cd not null,
3 tit_cd not null,
4 primary key (cod_cd))
5 nested table art_cd store as lista_artistas;
ARTISTAS: SQL> create table artistas of artista (
2 cod_art not null,
3 nome_art not null,
4 primary key (cod_art))
5 nested table cds_art store as lista_cds_art;
VENDAS: SQL> create table vendas of venda (
2 cod_ven not null,
3 data_ven not null,
4 valor_ven not null,
5 pago_ven not null,
6 cli_ven not null,
7 primary key (cod_ven))
8 nested table cds_ven store as lista_cds_ven;
29
Todas a tabelas estão criadas, o próximo passo é a manipulação de seus dados. Os

comandos de manipulação de dados no PL/SQL são os mesmos da linguagem SQL: insert,
update, e delete.
Nesta apostila estamos trabalhando com um modelo de dados orientado a objetos,
então estes comandos podem sofrer algumas modificações para tratar de tipos de dados
construídos pelo usuário. A seguir serão apresentados diversos exemplos de transações que
modificam os dados deste banco de dados.
7.2 Inserção de dados nas tabelas

A inserção de dados nas linhas das tabelas do BD é feita através do comando insert
da linguagem SQL e cada linha é inserida por vez.
Sintaxe: insert into nome_tabela [(atributos)] values (valores)
[returning atributo into variável];
7.2.1 Inserção de dados na tabela de Clientes
A inserção na tabela de clientes pode ser feita diretamente e executada no

SQL*Plus. Porém em CLIENTES existem atributos de tipos construídos pelo usuário,
“tels_cli” e “end_cli”, sendo assim, ao informar os valores que estes atributos irão receber,
deve-se informar o nome do seu tipo de objeto, como pode ser visto na Figura a seguir.
Para verificar se os dados realmente foram cadastrados, basta fazer uma consulta simples.
Figura 23: Inserção na tabela clientes no SQL*Plus.
30
Esta operação também poderia ser realizada no SQL*Plus Worksheet:
Figura 24: Inserção na tabela clientes no SQL*Plus Worksheet.

Observe que nos exemplos anteriores foi forçada uma validação, ou um
comprometimento do banco de dados, através do comando commit. Isto é muito importante
em qualquer tipo de comando de manipulação de dados no Oracle, pois este SGBD é
implementado com a técnica da atualização adiada, ou seja, os dados só serão gravados no
banco de dados físico, depois que tiverem sido comprometidos. Caso este comando não
seja executado, as alterações feitas ao banco de dados podem ser desfeitas, executando-se o
comando rollback.
Nota importante: É possível optar por tornar o Oracle um SGBD que realize as alterações
de forma imediata, através do comando “set autocommit on”.
7.2.2 Inserção de dados na tabela de Artistas
A inserção de dados deve seguir uma ordem predeterminada, a depender da

aplicação. Neste caso, vamos trabalhar da seguinte forma: primeiro os artistas serão
cadastrados, somente depois seus CDs poderão ser incluídos no BD. Sendo assim,
incluiremos apenas alguns dados dos artistas, deixando os dados referentes a seus CDs para
serem alterados no momento do cadastramento dos CDs.
31
Para inserir dados na tabela de ARTISTAS, a partir do SQL*Plus, ou do SQL*Plus

Worksheet, basta executar linhas de comando como as dos exemplos a seguir.
Figura 25: Inserção na tabela artistas no SQL*Plus.
Figura 26: Inserção na tabela artistas no SQL*Plus Worksheet.
32
7.2.3 Inserção de dados na tabela de CDs
A inserção na tabela de CDs deverá ser feita por um procedimento, pois envolve
uma série de operações que devem ser executadas de uma só vez. O procedimento
“insere_cd”, faz o seguinte:
• Recebe como parâmetros de entrada, o título do CD, o seu preço, a quantidade deste em
estoque, e o código de um artista. Deve ser selecionado o valor da referência para o artista.
• O código do novo CD deve ser gerado pelo sistema, incrementando o maior código.
• Caso ocorra a tentativa de cadastrar um CD de um artista que não tenha ainda sido
cadastrado no banco de dados, este erro deverá ser tratado e a mensagem “Artista não
cadastrado” será informada.
Observações: Cada uma das músicas do CD deve ser cadastrada depois. E caso este CD
contenha mais de um artista, os dados deste CD devem ser alterados para incluir novos
valores.
Procedimentos podem ser criados em diversos ambientes do Oracle. Para criar um
procedimento usando o DBA Studio, basta colocar um nome e seu código, como pode ser
visto na próxima Figura.
7.2.4 Inserção de dados na tabela de CDs
A inserção na tabela de CDs deverá ser feita por um procedimento, pois envolve
uma série de operações que devem ser executadas de uma só vez. O procedimento
“insere_cd”, faz o seguinte:
• Recebe como parâmetros de entrada, o título do CD, o seu preço, a quantidade deste em
estoque, e o código de um artista. Deve ser selecionado o valor da referência para o artista.
• O código do novo CD deve ser gerado pelo sistema, incrementando o maior código.
• Caso ocorra a tentativa de cadastrar um CD de um artista que não tenha ainda sido
cadastrado no banco de dados, este erro deverá ser tratado e a mensagem “Artista não
cadastrado” será informada.
Observações: Cada uma das músicas do CD deve ser cadastrada depois. E caso este CD
contenha mais de um artista, os dados deste CD devem ser alterados para incluir novos
valores.
33
Procedimentos podem ser criados em diversos ambientes do Oracle. Para criar um

procedimento usando o DBA Studio, basta colocar um nome e seu código.
Figura 26: Criação do procedimento insere_cd.

Caso a criação do procedimento tenha ocorrido sem problemas, a seguinte tela deve
ser mostrada. Caso contrário o procedimento pode ser criado com erros de compilação e
estes erros devem ser observados e corrigidos. Enquanto a compilação não obtiver sucesso,
o status do procedimento será “Inválido”.
Figura 27: Mensagem exibida quando o procedimento é criado com sucesso.
34
Para executar este procedimento deve-se digitar:

SQL> execute insere_cd (‘título do cd’, preço, quantidade, código do artista);
Figura 26: Execução do procedimento insere_cd.

A inserção de músicas num CD deve ser feita, uma a uma, da seguinte forma:
• Deve-se informar o código do CD a ser alterado e os dados referentes à música: o número,
o nome e a letra.
• Caso esta seja a primeira música, a lista deve ser gravada com os novos dados da música.
• Caso esta não seja a primeira música, a lista deve ser expandida e esta música colocada no
final da mesma.
• Os dados do CD devem ser alterados para conter esta nova música.
A seguir é mostrado o código para a criação deste novo procedimento e o seu
comando de chamada, desta vez utilizando o SQL*Plus.
Figura 29: Criação do procedimento insere_musica.
35
7.2.5 Inserção de dados na tabela de Vendas
Uma venda pode acontecer de duas formas diferentes:

1. Se o cliente for comprar só um CD, apenas o procedimento “insere_venda” é executado,
onde é feita a inserção de uma venda, contendo os dados do cliente e os dados de um CD
que este tenha comprado.
2. Se o cliente for comprar mais de um CD, primeiro é executado o procedimento
“insere_venda”, onde a venda é cadastrada e só depois para cada novo CD que venha a ser
vendido, a venda deve ser alterada, assim como o CD.
A seguir será apresentado o código para a criação do procedimento “insere_venda”
e o comando de execução do mesmo. Posteriormente o procedimento “altera_venda”,
responsável por incluir novos CDs numa venda será mostrado.
SQL> create or replace procedure insere_venda
2 (nomecli varchar2, codcd number) as
3 begin
4 declare novocod number;
5 preco number;
6 quant number;
7 refcli ref cliente;
8 refcd ref cd;
9 listacds refcds;
10 begin
11 select ref(cx) into refcli
12 from clientes cx where nome_cli=nomecli;
13
14 select ref(cx), preco_cd, qtd_cd
15 into refcd, preco, quant
16 from cds cx where cod_cd=codcd;
17
18 listacds:=refcds(refcd);
19 quant:=quant-1;
20
36
21 update cds set qtd_cd=quant

22 where cod_cd=codcd;
23
24 select max(cod_ven) into novocod from vendas;
25 if novocod is null then
26 novocod:=1;
27 else
28 novocod:= novocod+1;
29 end if;
30
31 insert into vendas
32 values (novocod, sysdate, preco, 'N', refcli, listacds);
33
34 commit;
35
36 exception
37 when no_data_found then
38 raise_application_error(-20100,”Cliente / CD não encontrado”);
39 end;
40 end;
41 /
Procedimento criado.
7.3 Alterações de dados das tabelas

A alteração de dados nas tabelas é feita através do comando update. Para alterar
dados de tipos básicos, o comando é o mesmo que em SGBD relacionais, a seguir são
apresentados alguns exemplos.
Sintaxe: update nome_tabela
set atributo1=valor1 [, atributo2=valor2, ..., atributoN=valorN]
[where condição];
Exemplo 1: Mudando o nome de um cliente.
SQL> update clientes set nome_cli='Olinda Nogueira Paes Cardoso'
37
2 where cpf_cli=’123456789012345’;
1 linha atualizada.
A seguir serão apresentados exemplos de alterações de dados de tipos construídos
pelo usuário.
Exemplo 2: Mudar parte do endereço de um cliente.
SQL> update clientes c set c.end_cli.ender = 'Rua Pedro Moura, 100/2'
2 where cpf_cli='123456789012345';
1 linha atualizada.
Exemplo 3: Alterar um CD incluindo novo artista.
Algumas alterações em tabelas podem gerar uma série de outras operações
necessárias para manter o banco de dados consistente. Por exemplo, ao alterarmos um CD,
incluindo um novo artista neste, devemos alterar a lista de CDs deste artista. Assim será
preciso construir um procedimento que realize estas operações.
A seguir será apresentado o código para a criação do procedimento
“altera_cd_artista”.
SQL> create or replace procedure altera_cd_artista
2 (codcd number, codart number) as
3 begin
4 declare listacds refcds;
5 listaart refartistas;
6 refcd ref cd;
7 refart ref artista;
8 begin
9 select ref(cx), art_cd into refcd, listaart
11
12 select ref(ax), cds_art into refart, listacds
13 from artistas ax where cod_art=codart;
14
15 listaart.extend;
16 listaart(listaart.last):=refart;
38
17
18 if listacds is null then
20 else
21 listacds.extend;
22 listacds(listacds.last):=refcd;
23 end if;
24
25 update cds set art_cd=listaart
27
28 update artistas set cds_art=listacds
29 where cod_art=codart;
30
31 commit;
32 exception
34 raise_application_error(-20100,”CD / Artista não encontrado”);
35 end;
36 end;
37 /
SQL> execute altera_cd_artista(1,2);
Procedimento PL/SQL concluído com sucesso.
Exemplo 4: Alterar uma venda, incluindo um novo CD.
Como explicado anteriormente, a cada novo CD que um cliente compre, este deve
ser incluído na venda e seu valor acrescido ao valor total, além disso, este CD deve ser
retirado do estoque. O procedimento apresentado a seguir recebe como parâmetros o código
da venda e o código do novo CD a ser comprado.
SQL> create or replace procedure altera_venda
2 (codvenda number, codcd number) as
39
3 begin
4 declare preco number;
5 valor number;
6 quant number;
7 refcd ref cd;
8 listacds refcds;
9 begin
10
11 select ref(cx), preco_cd, qtd_cd
12 into refcd, preco, quant
14
15 quant:=quant-1;
16 update cds set qtd_cd=quant
18
19 select cds_ven, valor_ven into listacds, valor
20 from vendas where cod_ven=codvenda;
21 valor := valor + preco;
22
23 if listacds is null then
25 else
26 listacds.extend;
27 listacds(listacds.last) := refcd;
28 end if;
29
30 update vendas set cds_ven=listacds, valor_ven=valor
31 where cod_ven=codvenda;
32
33 commit;
40
34 exception
36 raise_application_error(-20100,”CD não cadastrado”);
37 end;
38 end;
39 /
SQL> execute altera_venda(1,2);
Procedimento PL/SQL concluído com sucesso.
7.4 Remoção de dados das tabelas

A remoção de dados nas tabelas é feita através do comando delete, exatamente como
no SQL.
Sintaxe: delete from nome_tabela
[where condição];
A opção de remoção de dados padrão no Oracle é a de não permitir que um a
determinada instância do BD seja removida, caso esta possua alguma dependência. Ou seja,
a remoção é bloqueada no caso de haver dependência entre dados.
Sendo assim, a atitude padrão tomada pelo SGBD seria, em nossa da aplicação, não
permitir que um cliente que possui compras realizadas (vendas cadastradas para este) seja
removido. Assim como não seria possível remover CDs que possuam artistas cadastrados
neste e vice-versa. Em todos os casos a dependência existente está representada através do
uso de referências. Assumiremos nesses casos que o padrão será mantido, por motivos de
segurança dos dados.
Porém em outro caso, por exemplo, ao remover (ou cancelar) uma venda,
poderíamos tomar a atitude de permitir esta remoção, contanto que alguns cuidados sejam
tomados, pois a quantidade dos CDs que foram vendidos deve ser incrementada ao seu
estoque. Para isso criamos um gatilho (trigger), como pode ser observado na Figura abaixo:
41
Figura 30: Criação do trigger remove_venda.

Notas importantes:
1) Para podermos referenciar a linha que está sendo removida, utilizamos uma variável
do sistema chamada “:old”. Esta variável guarda todos os valores dos atributos da
linha que será removida, e estes valores podem ser acessados.
2) Como um gatilho é disparado sempre por alguma operação de manipulação de
dados, para confirmar as alterações sobre o BD, após a execução da operação deve
ser forçado o commit. O comando commit não pode ser executado dentro de um
gatilho.
42
Este gatilho será executado automaticamente (ou disparado) antes de cada operação
de delete a ser realizada sobre a tabela de vendas. O sincronismo (ou timing) que é
exatamente a escolha deste momento para a execução do gatilho, deve ser informado na
tela de sincronia, como mostrado na Figura a seguir:
Figura 31: Estabelecendo o momento de ativação do trigger.

Nota importante: Só conseguiremos acessar a variável “:old” caso a opção “Trigger for
Each Row” (ou “Gatilho para Cada Linha”) estiver ativada. Neste momento também é
possível modificar o nome desta variável.
Exemplo de remoção de uma venda:
SQL> delete from vendas where cod_ven=2;
1 linha deletada.
43
7.5 Consultas
A seleção de dados nas tabelas é feita através do comando select, exatamente como
no SQL. Todas as cláusulas válidas no SQL, valem no PL/SQL.
Sintaxe: select atributos [into variáveis]
from tabelas [where condições];
Esta sintaxe pode ser alterada para selecionar dados de objetos definidos pelo
usuário, pois é preciso algumas usar um alias para a tabela, como mostrado em algumas das
consultas a seguir.
Consulta 1: Mostrar as diferentes cidades de clientes cadastrados.
SQL> select distinct (c.end_cli.cidade)
2 from clientes c;
Para enxergar dados de tabelas aninhadas é preciso usar o construtor the, que cria
uma tabela temporária para guardar estes dados e assim torná-los acessíveis, observe as
consultas 2 e 3.
Consulta 2: Mostrar os nomes das músicas cadastradas num CD.
SQL> select m.nome_mus
2 from the (select mus_cd from cds where cod_cd=1) m;
Consulta 3: Mostrar o nome de uma música cadastrada num CD.
SQL> select m.nome_mus
2 from the (select mus_cd from cds where cod_cd=1) m
3 where m.num_mus=3;
Todas as funções presentes no SQL podem ser usadas no PL/SQL, tais como as
funções COUNT, SUM, AVG, MAX, MIN, dentre outras. Estas também podem ser
aplicadas a objetos, como apresentado na consulta 4.
Consulta 4: Mostrar a quantidade de músicas cadastradas em um CD.
SQL> select count(m.nome_mus)
Consulta 5: Mostrar a soma de vendas que já foram pagas.
SQL> select SUM(valor_ven) from vendas where pago_ven='S';
44
As opções de agrupamento (group by) e ordenação (order by) também podem ser
usadas. Assim como operações sobre conjuntos, como UNION, INTERSECTION, IN,
EXISTS, etc.
Consulta 6: Mostrar músicas de um CD, ordenados pelo seu número e nome.
SQL> select m.num_mus, m.nome_mus
3 order by 1,2;
Consulta 7: Mostrar as músicas de dois CDs diferentes.
SQL> select m.num_mus, m.nome_mus
3 union
4 select m.num_mus, m.nome_mus
Consulta 8: Mostrar o nome do cliente que efetuou uma determinada venda.
Como os dados do cliente na tabela de vendas estão apenas referenciados,
precisamos o usar o deref, porém este retornará uma linha contendo todos os dados do
cliente e não só o seu nome. Assim precisaremos usar uma variável temporária para
armazenar estes dados e depois mostrar na tela apenas o valor do nome. Para isto usaremos
a função “dbms_output.put_line(...)” que imprime os resultados em linhas diferentes.
SQL> declare cli cliente;
2 begin
3 select deref(cli_ven) into cli
4 from vendas where cod_ven=1;
5
6 dbms_output.put_line(cli.nome_cli);
7 end;
8/
Nota importante: Para visualizar dados de saída no SQL*Plus, deve-se habilitar a opção
“set serveroutput on”, antes de executar o procedimento de consulta. Sem isto, o
procedimento poderá ser executado com sucesso, mas os resultados da consulta não
poderão ser visualizados.
45
Algumas consultas, a depender dos tipos de dados da tabela, podem ser tão
complexas que precisem de várias operações para solucioná-las. Sendo assim, pode-se criar
procedimentos ou funções para este tipo de consulta, como é o caso das consultas a seguir.
Consulta 9: Mostrar os títulos dos CDs vendidos, a partir do código da venda.
Na tabela VENDAS o atributo “cds_ven” é do tipo REFCDS, que, por sua vez, é de
um tipo de tabela formado por um conjunto de referências ao objeto CD. Uma variável do
mesmo tipo “listacds” será usada para receber os dados do BD. Esta lista será percorrida
numa estrutura de repetição, para que a referência de cada CD seja desfeita, obtendo todos
os dados do CD.
Uma vez obtidos os dados de cada CD, o título deste será mostrado na tela, como
resposta a consulta.
Figura 32: Criação do procedimento cds_venda.
46
Para executar este procedimento basta fazer:

SQL> exec cds_venda (código_da_venda);
Os procedimentos para as consultas 10 e 11 são similares ao anterior, por isso não
serão explicados.
Consulta 10: Mostrar o nome de um determinado artista e os seus CDs.
SQL> create or replace procedure cds_artista (codart number) as
2 begin
3 declare
4 refcd ref cd;
5 listacds refcds;
6 tit varchar2(30);
7 nome varchar2(40);
8 ind number;
9 begin
10 select cds_art, nome_art into listacds, nome
11 from artistas where cod_art=codart;
12
13 dbms_output.put_line(nome);
14
15 ind:=1;
16 loop /*repete até que a lista chegue ao fim*/
17 refcd:=listacds(ind);
18 select tit_cd into tit from cds c where ref(c)=refcd;
19 dbms_output.put_line(tit);
20 exit when listacds(ind)=listacds(listacds.last);
21 ind:=ind + 1;
22 end loop;
23
24 exception /*para tratar um possível erro*/
26 raise_application_error(-20100, 'Artista não cadastrado');
47
27
28 end;
29 end;
30 /
SQL> exec cds_artista (código_do_artista);
Consulta 11: Mostrar o título de um CD e os nomes dos seus artistas.
SQL> create or replace procedure artistas_cd (codcd number) as
2 begin
3 declare
4 refart ref artista;
5 lista refartistas;
6 tit varchar2(30);
7 nome varchar2(40);
8 ind number;
9 begin
10 select art_cd, tit_cd into lista, tit
11 from artistas where cod_cd=codcd;
12
13 dbms_output.put_line(tit);
14
15 ind:=1;
16 loop /*repete até que a lista chegue ao fim*/
17 refart:=lista(ind);
18 select nome_art into nome
19 from artistas a where ref(a)=refart;
20 dbms_output.put_line(nome);
21 exit when lista(ind)=lista(lista.last);
22 ind:=ind + 1;
23 end loop;
48
24
25 exception /*para tratar um possível erro*/
27 raise_application_error(-20100, 'CD não cadastrado');
28
29 end;
30 end;
31 /
SQL> exec artistas_cd (código_do_cd);
Foram apresentados apenas alguns exemplos de possíveis consultas realizadas sobre
esta aplicação. Estas consultas devem servir de base para a criação de outros exemplos que
poderiam ser implementados.
8 Referências
Abbey, M., Corey, M.J., Abramson, I., Oracle8i Guia Introdutório, Editora
Campus, autorizado pela Oracle Press, Rio de Janeiro, 2000.
Elmasri, Ramez; Navathe, B. Shamkant. Sistemas de Banco de Dados –
Fundamentos e Aplicações. Editora LTC. Versão Traduzida, Terceira Edição, Rio
de Janeiro, 2002.
Loney, K., Koch, G., Oracle8i: The Complete Reference, Editora McGraw-Hill,
autorizado pela Oracle Press, Berkeley, 2000.
Página oficial da Oracle Corporation na Internet. Disponível em:
http://www.oracle.com
49

Banco de Dados Objeto-Relacionais em Oracle

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Banco de Dados Objeto-Relacionais em Oracle

Uploaded by

Copyright:

Available Formats

Bancos de Dados

Cristhiane Xavier Figueiredo

{kristhy, jufafran, olinda}@comp.ufla.br

2 BD Relacional, Orientado a Objeto e Objeto-Relacional

de texto, bem como em relação à necessidade de definir operações específicas de aplicações

2.1 A tecnologia de BD Objeto Relacionais

A boa aceitação do modelo relacional é ajudada por uma infra-estrutura muito

2.2 Alguns conceitos básicos de Orientação a Objetos

Alguns conceitos da orientação a objetos foram acrescentados à tecnologia de

• Polimorfismo e sobrecarga do operador: Nomes de métodos e operações podem

2.3 Características Objeto-Relacionais no Oracle

O Oracle é um bom exemplo de SGBDO-R. Ele continua a prover as

2.3.1 Representação de Atributos Multivalorados pela Utilização do VARRAY

Alguns atributos de um objeto/entidade podem ser multivalorados. No modelo

Considere o exemplo de uma entidade VARRAY cliente com os atributos nome

Agora podemos criar o tipo de dado tipo_cliente como um objeto com os

2.3.2 Utilização de Tabelas Aninhadas para Representar Objetos Complexos

Na modelagem de objetos, alguns atributos de um objeto poderiam ser eles próprios

Em seguida, redefinimos tipo_lista_telefone como uma tabela de

Podemos, então, criar o tipo chamado tipo_cliente e a tabela chamada cliente

invés de um VARRAY. Ambas as estruturas têm funções semelhantes, com algumas

3.1 SQL e Oracle

O Oracle Server interpreta apenas instruções em SQL – quando ferramentas como o

O SQL é personalizado para aproveitar a simplicidade do modelo relacional. Como

3.2 SQL*Plus Worksheet

Figura 2: O SQL*Plus Worksheet.

Figura 3: Tela inicial do DBA Studio.

A Figura 4 apresenta a tela de login do DBA Studio, onde o usuário deve se

Figura 4: Tela de login no DBA Studio.

Nessa tela, o usuário tem a opção de se conectar como um usuário “Normal”, ou

Figura 5: Tela principal do DBA Studio.

Com o gerenciador de armazenamento do DBA Studio é possível administrar

Figura 6: Gerenciador de armazenamento do DBA Studio.

O gerenciamento de instâncias do DBA Studio permite que o usuário dê um startup

Com relação ao gerenciamento de esquemas, o DBA Studio permite ao usuário

Figura 7: Gerenciamento de esquemas no DBA Studio.

O gerenciamento de segurança do DBA Studio permite que administradores

Figura 8: Gerenciamento de segurança no DBA Studio.

5 Oracle e a Tecnologia Objeto Relacional

5.1 O que é um banco de dados objeto-relacional?

5.1.1 Tipo de Objeto

Um tipo de objeto define a estrutura de um objeto (object), que armazena dados

5.1.3 Coleções: Tipo de Tabela e Vetor

6.1 Objetos Armazenados

6.1.1 Funções / Procedimentos Armazenados

Procedimento ou função armazenada (stored procedure) é um código associado a

Os procedimentos e as funções podem ou não receber parâmetros de entrada e saída.

Um pacote é um conjunto de procedimentos e funções empacotados, normalmente

Um gatilho (trigger) é um procedimento que é associado a uma tabela do banco de

6.2 Características da PL/SQL

6.2.1 Conjunto de caracteres

O programador está limitado aos seguintes caracteres:

As regras para a definição das variáveis são:

6.2.3 Palavras reservadas

Como em outras linguagens de programação, palavras reservadas não podem ser

6.2.4 Tipos de dados comuns

Os tipos de dados básicos comuns a linguagem PL/SQL são:

6.2.5 Estrutura de blocos

6.2.6 Estruturas de controle

As estruturas de controle da PL/SQL são: o controle de programa, três tipos de

A seção exception é o método da PL/SQL para tratar de condições de erro, ou seja,

Exemplo de tratamento de erro num bloco de programa:

Para inserir dados na tabela de ARTISTAS, a partir do SQLPlus, ou do SQLPlus