Oracle

Material de Apoio

Elaborado por: Evaldo de Oliveira

 SUMÁRIO
1. Conceitos sobre Banco de Dados Relacional ............................................................................. 5
1.1. Modelo Relacional ................................................................................................................. 5
1.2. Componentes do modelo Relacional ..................................................................................... 5
1.3. Características de um Banco de Dados Relacional................................................................ 5
1.4. Modelos de Dados ................................................................................................................. 5
1.5. Objetivo dos Modelos ............................................................................................................ 6
1.6. Diagrama de Entidades e Relacionamentos........................................................................... 6
1.7. Elementos básicos de um DER .............................................................................................. 6
1.8. Tipos de atributos .................................................................................................................. 7
1.9. Relacionamentos .................................................................................................................... 7
1.10. Tipos de Relacionamentos ................................................................................................ 7
1.11. Cardinalidade de Relacionamentos ................................................................................... 8
1.12. Cardinalidade Um para Um............................................................................................... 9
1.13. Cardinalidade Um para Muitos ....................................................................................... 10
1.14. Cardinalidade Muitos para Muitos .................................................................................. 10
 Processo de Desenvolvimento de Software.............................................................................. 11
2.1. Fases do Processo Unificado ............................................................................................... 11
2.2. Concepção............................................................................................................................ 11
2.3. Organização dos Requisitos................................................................................................. 13
2.4. Organização dos Requisitos em Casos de Usos .................................................................. 13
2.5. Organização dos Requisitos em Funções de Conceitos....................................................... 14
2.6. Elaboração ........................................................................................................................... 15
2.7. Construção ........................................................................................................................... 15
2.8. Transição.............................................................................................................................. 15
 SQL – Structure Query Language ............................................................................................ 17
3.1. Sobre PL/SQL...................................................................................................................... 18
3.2. Instruções SQL .................................................................................................................... 18
 Oracle 11g – Express Edition – Uma visão geral do SGBD .................................................... 19
4.1. Limitações do Oracle11g ..................................................................................................... 19
 Tabelas usadas no Curso .......................................................................................................... 21
5.1. Diagrama de Entidades-Relacionamento............................................................................. 21
5.2. Modelo Físico das tabelas usadas no Curso ........................................................................ 21
5.3. Executando o Script de Criação das tabelas usadas no curso .............................................. 22
 Instruções Básicas da linguagem SQL ..................................................................................... 23
6.1. Os principais recursos das Instruções SELECT SQL .......................................................... 23
6.2. Facilitando a leitura das colunas – Exibindo a estrutura das tabelas ................................... 23
6.3. A sintaxe básica da instrução SELECT ............................................................................... 23
6.4. Selecionando todas as colunas de uma tabela...................................................................... 24
6.5. Especificando a seleção de Colunas .................................................................................... 24
6.6. O uso de expressões aritméticas .......................................................................................... 24
6.7. O valor nulo na instrução SELECT SQL ............................................................................ 25
6.8. Nomeando colunas através de apelidos ............................................................................... 25
6.9. Concatenando colunas ......................................................................................................... 25
6.10. Eliminação de Linhas Duplicadas ................................................................................... 25
6.11. Exercícios ........................................................................................................................ 26
 Limitando e classificando as linhas recuperadas ...................................................................... 28
7.1. Limitando o retorno de linhas .............................................................................................. 28
7.2. Trabalhando com operadores de comparação...................................................................... 29
 7.3. Trabalhando com operadores lógicos .................................................................................. 30
7.4. A cláusula ORDER BY ....................................................................................................... 31
7.5. Exercícios ............................................................................................................................ 32
 Trabalhando com Funções SQL no Oracle11g ........................................................................ 33
8.1. Funções para manipulação de Caractere.............................................................................. 33
8.2. Funções para manipulação de tipos numéricos ................................................................... 34
8.3. Trabalhando com Datas no Oracle11g ................................................................................ 35
8.4. Aritmética com Datas .......................................................................................................... 35
8.5. Funções de Data................................................................................................................... 36
8.6. Funções usadas para converter data ou valores numéricos ................................................. 37
8.7. A função TO_CHAR ........................................................................................................... 37
8.8. Elementos dos Formatos de Data ........................................................................................ 38
8.9. O uso da função TO_CHAR formatando números.............................................................. 39
8.10. A função TO_NUMBER................................................................................................. 40
8.11. A função TO_DATE ....................................................................................................... 40
8.12. A função NVL ................................................................................................................. 40
8.13. A função DECODE ......................................................................................................... 40
8.14. Aninhamento de Funções ................................................................................................ 41
8.15. Exercícios ........................................................................................................................ 41
 Desenvolvendo consultas com exibição de dados de várias tabelas ........................................ 42
9.1. Exercícios ............................................................................................................................ 44
 Agregação de dados usando funções ........................................................................................ 45
10.1. As funções de Grupo SUM, AVG, MAX e MIN ............................................................ 45
10.2. A função COUNT ........................................................................................................... 46
10.3. Grupos de Dados ............................................................................................................. 46
10.4. Funções para agurpamento de dados............................................................................... 46
10.5. Erros que ocorrem usando as funções para agrupamento de dados ................................ 47
10.6. Exercícios ........................................................................................................................ 48
 Criação de subconsultas ........................................................................................................... 49
11.1. Construindo Subconsultas de um única linha ................................................................. 50
11.2. Construindo Subconsultas de várias linhas ..................................................................... 51
11.3. Exercícios ........................................................................................................................ 52
 DML (Data Manipulation Language)....................................................................................... 53
12.1. Inserindo registros com a instrução INSERT.................................................................. 53
12.2. Inserindo linhas de registros a partir de outra tabela....................................................... 54
12.3. Modificando linhas usando a instrução UPDATE .......................................................... 54
12.4. Apagando linhas usando a instrução DELETE ............................................................... 55
12.5. Controle de transações .................................................................................................... 55
12.6. Exercícios ........................................................................................................................ 56
 Criação e Gerenciamento de Tabelas ....................................................................................... 57
13.1. Instruções de modificação e deleção de tabelas .............................................................. 58
13.2. Exercícios ........................................................................................................................ 59
 Restrições em tabelas ............................................................................................................... 60
14.1. Modificando as restrições de uma tabela ........................................................................ 61
14.2. Exercícios ........................................................................................................................ 61
 Criação de Views...................................................................................................................... 63
15.1. Exercícios ........................................................................................................................ 64
 Instruções e comandos avançados para Administração do Oracle 11g XE.............................. 65
16.1. Iniciando e abrindo o banco de dados por meio de comandos........................................ 65
16.2. Exercícios ........................................................................................................................ 67
16.3. Organização Lógica: Tablespaces ................................................................................... 68
16.4. Criação de Tablespaces ................................................................................................... 68
 16.5. Alteração de Tablespaces ................................................................................................ 70
16.6. Eliminação de Tablespaces ............................................................................................. 71
16.7. Exercícios ........................................................................................................................ 71
16.8. Criação de Tabelas com parâmetros de armazenamento ................................................ 72
16.9. Alteração de Tabelas ....................................................................................................... 73
16.10. Adição de Colunas .......................................................................................................... 73
16.11. Renomear Colunas .......................................................................................................... 74
16.12. Deleção de Colunas ......................................................................................................... 74
16.13. Adição de Constraints ..................................................................................................... 74
16.14. Primary Keys ................................................................................................................... 74
16.15. Foreign Keys ................................................................................................................... 74
16.16. Deleção de Constraints .................................................................................................... 75
16.17. Modificação de Colunas .................................................................................................. 75
16.18. Desabilitar e Habilitar de Foreign Keys .......................................................................... 75
16.19. Apagar uma Tabela ........................................................................................................ 75
16.20. Listar a estrutura de uma Tabela ..................................................................................... 75
16.21. Exercícios ........................................................................................................................ 76
16.22. Criação de Índices com parâmetros de armazenamento ................................................. 77
16.23. Exercícios ........................................................................................................................ 78
16.24. Restrições de Integridade ................................................................................................ 79
16.25. Restrições baseadas em esquema .................................................................................... 79
16.26. Restrições de Domínio .................................................................................................... 79
16.27. Restrições de Chave ........................................................................................................ 79
16.28. Check Constraint ............................................................................................................. 80
16.29. Restrições baseadas em aplicação ................................................................................... 80
16.30. Assertion.......................................................................................................................... 80
16.31. Triggers ou Gatilhos ........................................................................................................ 80
16.32. Criação de Triggers ......................................................................................................... 81
16.33. Criação de Triggers com INSERT .................................................................................. 82
16.34. Criação de Triggers com UPDATE ................................................................................ 83
16.35. Criação de Triggers com DELETE ................................................................................. 83
16.36. Segurança e Nível de Acesso .......................................................................................... 84
16.37. Usuários........................................................................................................................... 84
16.38. Privilégios de Sistema ..................................................................................................... 85
16.39. Privilégios de Objeto ....................................................................................................... 86
16.40. Roles ................................................................................................................................ 87
16.41. Exercícios ........................................................................................................................ 88
16.42. Cópias de Segurança e Restauração de Banco de Dados ................................................ 89
16.43. Exportação de Banco de Dados....................................................................................... 89
16.44. Importação de Banco de Dados....................................................................................... 89
16.45. Comandos para Backup e Restore................................................................................... 90
16.46. Exercícios ........................................................................................................................ 92
16.47. Comando COPY.............................................................................................................. 93
16.48. Criando Database Links .................................................................................................. 94
16.49. Exercícios ........................................................................................................................ 95
Referências......................................................................................................................................... 96
 5

1. Conceitos sobre Banco de Dados Relacional

Este capítulo aborda alguns conceitos básicos sobre os bancos de dados relacionais. Segundo
Elmasri e Navathe [ELM e NAV 05], o modelo relacional foi introduzido por Ted Codd, da IBM
Research, em 1970, em um artigo clássico (Codd, 1970) que imediatamente atraiu a atenção em
virtude de sua simplicidade e base matemática. O modelo usa o conceito de uma relação
matemática- algo como uma tabela de valores - como seu bloco de construção básica e tem sua
base teórica na teoria dos conjuntos e na lógica de predicados de primeira ordem.
As primeiras implementações comerciais do modelo relacional tornaram-se disponíveis no
início da década de 80, como o SGBD Oracle e o sistema SQL/DS do sistema operacional MVS, da
IBM. Desde essa época, o modelo tem sido implementado em um grande número de sistemas
comerciais. Os SGBDs relacionais (SGBDRs) mais conhecidos atualmente são o DB2 e o Informix
Dynamic Server (da IBM), o Oracle e o SQL Server.
Os modelos de dados que precederam o modelo relacional compreendem os modelos
hierárquico e de rede. Foram propostos na década de 60 e implementados em antigos SGBDs
durante as décadas de 70 e 80.

1.1. M odelo Relacional

Os princípios do modelo relacional foram definidos primeiramente palo Dr. Edgar Frank
"Ted" Codd em junho de 1970 em um estudo chamado “A Relational Model of Data for Large
Shared Data Banks”. Nesse estudo, o Dr. Codd propôs o modelo relacional de sistemas de bancos
de dados.
Os modelos mais populares usados naquele tempo eram hierárquicos, de rede ou mesmo
estruturas de dados de arquivos simples. Os RDBMS (Relational Database Management Systems)
em breve se tornaram muito populares, especialmente pela facilidade de uso e flexibilidade na
estrutura. Além disso, vários fornecedores inovadores, como a Oracle, ofereciam o RDBMS com
um conjunto eficiente de desenvolvimento de aplicações e produtos para usuários, formando uma
solução completa.

1.2. Componentes do modelo Relacional

 Conjuntos de objetos ou relações que armazenam os dados.
 Conjunto de operadores que podem agir sobre as relações para produzir outras
relações.
 Integridade de dados para precisão e consistência.

Caso seja interessante, é importante que seja consultado o artigo E.F. Codd, The Relational
Model for Database Management.

1.3. Características de um Banco de Dados Relacional

Um banco de dados relacional usa relações ou tabelas bidimensionais para armazenar
informações. Por exemplo, você pode armazenar informações sobre todos os empregados de uma
empresa. Em um banco de dadso relacional, você cria várias tabelas para armazenar informações
diferentes sobre empregados, como tabelas de empregados, departamentos e salários.

1.4. M odelos de Dados

Um modelo de dados é um conjunto de conceitos que podem ser usados para descrever a
estrutura e as operações em um banco de dados [CAS 05]. Este modelo busca resumir o significado
dos fenômenos e objetos do mundo real, os quais serão traduzidos para um sistema computacional.
Deve-se considerar que os objetos e os fenômenos reais são muito complexos, sendo necessária
uma abstração do mundo real a fim de formar uma representação conveniente e que seja adequada
 6
às finalidades do banco de dados.
É através da abstração dos conceitos, características e relações existentes entre as entidades do
mundo real que é gerado um modelo conceitual, e quando bem elaborado, possibilita o sucesso de
qualquer implementação. O sucesso do projeto depende da transformação dos objetos representados
no modelo e suas relações para um banco de dados informatizado. É importante para o projetista
considerar durante a fase de modelagem, que o modelo conceitual trata de um artefato que
representa o domínio do problema, e não se refere como o problema será solucionado através de
diagramas de classes de projeto, embora sejam resultados do modelo conceitual [WAZ 04].

1.5. Objetivo dos M odelos

Os modelos ajudam a comunicar conceitos imaginados pelas pessoas. É possível usá-los com
os seguintes objetivos:
 Comunicar;

 Categorizar;

 Descrever;

 Especificar;

 Investigar;

 Desenvolver;

 Analisar.

O objetivo é produzir um modelo que se adapte a vários usos, e que possa ser compreendido
por um usuário final contendo detalhes suficientes para que um desenvolvedor crie um sistema de
banco de dados.

1.6. Diagrama de Entidades e Relacionamentos

Um DER (Diagrama de Entidades e Relacionamentos) considera que os dados são
independentes do processamento de transformação. No que diz respeito à análise, um DER define
os dados que serão mantidos pelo sistema.

1.7. Elementos básicos de um DER

Entidades – Elementos concretos ou abstratos. Exemplo: PESSOA, ATRIBUTOS, CARRO.

PESSOA
Figura 1.1. Representação de Entidade em um DER.

Atributos da Entidade – São as propriedades da entidade. Exemplos: Atributos da entidade

PESSOA: CPF, NOME, DATA DE NASCIMENTO, NACIONALIDADE.
 7

PESSOA

NACIONALIDADE
CPF NOME DTNASC

Figura 1.2. Representação de Atributos em um DER.

Relacionamentos entre Entidades – Exemplo: Uma PESSOA possui 1 ou vários CARROS.

PESSOA POSSUI CARRO

Figura 1.3. Representação de Relacionamento em um DER.

1.8. Tipos de atributos

 Atributo chave. Valor é distinto para cada instância da entidade.

CPF PESSOA

Figura 1.4. Representação do Atributo chave no DER.

 Atributo composto. Subdividido e atributos mais básicos.

BAIRRO

ENDEREÇO PESSOA
CIDADE

Figura 1.5. Representação do Atributo Composto no DER.

 Atributo multivalorado. Vários valores para cada instância de entidade.

 Atributo derivado. Atributo calculado a partir de outros.

1.9. Relacionamentos
Segundo Heuser [HEU 98] além de especificar os objetos sobre os quais deseja-se manter
informações, o DER deve permitir a especificação das propriedades dos objetos que serão
armazanedas no BD. Uma das propriedades sobre as quais pode ser desejável manter informações é
a associação entre objetos. Por exemplo, supondo que seja desejável saber quais pessoas estão
associadas as quais departamentos em uma organização. Ou seja, um relacionamento é um conjunto
de associações entre entidades.

1.10. Tipos de Relacionamentos

Relacionamento Unário (Auto-Relacionamento).

 8

gerente
EMPREGADO GERENCIA
gerenciado
Figura 1.6. Relacionamento Unário.

Relacionamento Binário

ALUNO MATRICULA DISCIPLINA

Figura 1.7. Relacionamento Binário.

Relacionamento Ternário.

PROJETO FORNECE FORNECEDOR

PEÇA

Figura 1.8. Relacionamento Ternário.

1.11. Cardinalidade de Relacionamentos

Segundo Heuser [HEU 98] para fins de projeto de banco de dados, uma propriedade
importante de um relacionamento é a de quantas ocorrências de uma entidade podem estar
associadas a uma determinada ocorrência através do relacionamento. Essa propriedade é chamada
de cardinalidade de uma entidade em um relacionamento. Há duas cardinalidades a considerar: a
cardinalidade máxima e a cardinalidade mínima. Ou seja, a cardinalidade (mínima, máxima) de
entidade em relacionamento é o número de ocorrências de entidade associadas a uma ocorrência da
entidade em questão através do relacionamento.
Para exemplificar a cardinalidade máxima em um relacionamento, temos as seguinte situação:

EMPREGADO LOTACAO DEPARTAMENTO

120 1

Figura 1.9. Cardinalidade Máxima. 1 DEPARTAMENTO pode ter no máximo 120 EMPREGADOS.

 Entidade EMPREGADO tem cardinalidade máxima 1 no relacionamento LOTACAO.

 Entidade DEPARTAMENTO tem cardinalidade máxima 120 no relacionamento
LOTACAO.
 9

Isso não significa que uma ocorrência de DEPARTAMENTO pode estar associada a no
máximo 120 ocorrências de EMPREGADO, ou em outros termos, que um departamento pode ter
nele lotado no máximo 120 empregados.
Para fins práticos, não é necessário distinguir entre diferentes cardinalidades máximas
maiores que 1. Por este motivo, apenas duas cardinalidades máximas são relevantes: a cardinalidade
máxima 1 e a cardinalidade máxima “muitos”, referida pela letra n. Assim, no exemplo acima, diz-
se que a cardinalidade máxima da entidade DEPARTAMENTO no relacionamento LOTACAO é n.

EMPREGADO LOTACAO DEPARTAMENTO

N 1

Figura 1.10. Cardinalidade Máxima. 1 DEPARTAMENTO pode ter no máximo N EMPREGADOS.

Além da cardinalidade máxima, uma outra informação que pode ser representada por um
modelo ER é o número de ocorrências de entidade que são associadas a uma ocorrência de uma
entidade através de um relacionamento. Para fins de projeto de BD, consideram-se apenas duas
cardinalidades mínimas: a cardinalidade mínima 0 e a cardinalidade mínima 1. A cardinalidade
mínima 1 também recebe a denominação de “associação obrigatória”, já que ela indica que o
relacionamento deve obrigatoriamente associar uma ocorrência de entidade a cada ocorrência da
entidade em questão. Um exemplo prático do uso da cardinalidade mínima no relacionamento, seria
cada empregado deve ter a ele alocada obrigatoriamente uma mesa (cardinalidade mínima 1) e que
uma mesa pode existir sem que a ela esteja alocado um empregado (cardinalidade mínima 0).

EMPREGADO ALOCACAO MESA

(0,1)) (1,1)

Figura 1.11. Cardinalidade Mínima e Máxima.

1.12. Cardinalidade Um para Um

CHEFIA
PAÍS PRESIDENTE
(1,1) (1,1)

Figura 1.12. Relacionamento 1 para 1 definido pelas cardinalidades.

 10
1.13. Cardinalidade Um para Muitos

EMPREGADO TRABALHA DEPARTAMENTO

(1,M) (1,1)

Figura 1.13. Relacionamento 1 para “muitos” definido pelas cardinalidades.

1.14. Cardinalidade Muitos para Muitos

OFERTA – CANDIDATO
CANDIDATO EMPREGO EMPRESA
(M,N) (M,N)

Figura 1.14. Relacionamento “muitos” para “muitos” definido pelas cardinalidades.

 11

 Processo de Desenvolvimento de Software

Da concepção à transição, pode-se projetar e desenvolver um banco de dados para um sistema
de informação dentro do contexto de processo de construção de software, o qual contém várias
etapas.
A abordagem completa e sistemática para o desenvolvimento de muitos sistemas de
informação, tem como conseqüência a análise e o projeto de banco de dados, transformando as
necessidades de informações comerciais em um banco de dados operacional.
Esta parte da apostila aborda, de forma sucinta, o processo unificado de desenvolvimento de
software, conhecido como RUP, ou Rational Unified Process (Figura 2.1), o qual, da maneira
proposta, está fortemente associado à notação UML. Este processo comporta, em suas
recomendações, as antigas fases de estudo de viabilidade, análise de requisitos, análise de domínio,
e o projeto em múltiplas camadas. As etapas do RUP são: concepção, elaboração, construção e
transição.

Concepção Construção

Transição
Elaboração

Figura 2.1. Ciclo de vida de software baseado em ciclos iterativos. (Fonte: Wazlawick [WAZ 04])

2.1. Fases do Processo Unificado

Antes de qualquer associação do processo de desenvolvimento de software com a modelagem
e construção de banco de dados, é necessário entender as fases do RUP.
A concepção deve ser a primeira fase do processo de desenvolvimento de software, na qual os
projetistas levantam os principais requisitos para compreender o sistema de forma abrangente.
As fases de elaboração e construção ocorrem dentro dos ciclos iterativos. A elaboração é
constituída de análise e projeto, e a construção corresponde à implementação e aos testes. Nos
ciclos iterativos que acontece a análise detalhada do sistema (análise de requisitos e a análise de
domínio), onde também é feito o projeto do sistema, usando padrões de análise e padrões de projeto
como forma de reutilização de regras de negócios e implementações.
Nos ciclos iterativos são feitos as implementações dos códigos e os testes. Quando os ciclos
iterativos terminam, tem-se então um sistema que está praticamente pronto, faltando apenas os
testes finais de integração e de implantação junto ao usuário.
A fase de transição ocorre após o último ciclo iterativo, quando o sistema, depois de pronto,
será implantado na empresa, substituindo o sistema atual, seja ele manual ou computadorizado.

2.2. Concepção

Na fase de concepção é necessário que seja feito o estudo das necessidades comerciais e
transacionais. É importante que os usuários e gestores sejam entrevistados para identificar as
necessidades das informações a serem geradas. Além disso, deve-se incorporar as declarações de
objetivos da aplicação e da empresa, permitindo qualquer especificação futura do sistema.
Segundo Wazlawick [WAZ 04], a fase de concepção consiste em uma etapa na qual o
projetista deve buscar as primeiras informações sobre o sistema a ser desenvolvido. Portanto, nesta
 12
etapa, assume-se pouco conhecimento do projetista sobre o sistema, e uma grande interação com o
usuário e cliente.
Trata-se do entendimento das principais regras de negócios existentes e terminologias a serem
usadas no desenvolvimento do sistema, entendendo a semântica dos dados a serem armazenados.
Através do levantamento de requisitos, que é uma atividade da etapa de concepção, é possível
se ter uma visão geral do sistema baseando-se nas descrições feitas pelos usuários e clientes
entrevistados.
O levantamento de requisitos é formalizado e documentado em requisitos funcionais e não-
funcionais do sistema a ser desenvolvido. Abaixo segue um exemplo de uma especificação de
requisitos funcionais e não-funcionais associados (Figura 2.2).

F1 Registrar Emprestimos
Descrição: O sistema deve registrar empréstimos de fitas, indicando o cliente e as fitas que foram
emprestadas, bem como a data do empréstimo e o valor previsto para pagamento na devolução.
Requisitos Não-Funcionais
Nome Restrição Categoria Desejável Permanente
NF 1.1 Controle de A função só pode ser acessada
Acesso por usuário com perfil de Segurança ( ) ( )
operador ou superior.
NF 1.2 Identificação As fitas devem ser identificadas
Interface ( ) ( )
de Fitas por um código de barras.
NF 1.3 Identificação O cliente deverá ser identificado
Interface ( ) ( )
do Cliente a partir de seu nome.
NF 1.4 Tempo de O tempo para registro de cada fita
Performance ( ) ( )
Registro deve ser inferior a um segundo.
NF 1.5 Janela Única Todos as funções relacionadas a
empréstimos devem ser efetuadas Interface ( ) ( )
em uma única janela.
Figura 2.2. Exemplo de tabelas que e specificam requisitos funcionais e não-funcionais associados.
Fonte : Wazlawick [WAZ 04].

Durante a fase de concepção e listagem dos requisitos, torna-se importante especificar os

requisitos de forma detalhada, categorizando os requisitos não-funcionais.
Os requisitos não-funcionais podem ser classificados em várias categorias. Algumas sugestões
de possíveis categorias são listadas a seguir [WAZ 04]:

a) Usabilidade: quais fatores humanos estão envolvidos no sistema? Quais tipos de ajuda
o sistema vai prover? Quais as formas de documentação ou manuais disponíveis?
Como esses manuais vão ser produzidos? Que tipo de informação eles vão conter? É
imprescindível que estes tópicos sejam definidos na fase de concepção.

b) Confiabilidade: que tipo de tratamento de falhas o sistema vai ter? O projetista não é
obrigado a produzir um ambiente tolerante a falhas, mas deve estabelecer que tipos de
falhas o sistema será capaz de gerenciar.

c) Performance: que tipo de eficiência e precisão o sistema será capaz de apresentar?

Pode-se estabelecer, por exemplo, como requisito de eficiência, que nenhuma
consulta à base de dados de clientes vai demorar mais de cinco segundos.

d) Configurabilidade: o que pode se configurado no sistema? Devem-se definir os

elementos que poderão ser configurados pelo usuário sem a necessidade de
recompilar o sistema.
 13

e) Segurança: quais são os tipos de usuários e que funções cada um pode executar?
Sugere-se definir os perfis de usuários como um requisito suplementar e adicionar um
requisito não-funcional de “controle de acesso” a todos os requisitos funcionais, para
indicar como o acesso às funções do sistema é controlado.

f) Implementação: qual linguagem deve ser usada? Por que motivo? Quais bibliotecas
estarão disponíveis? Quais banco de dados serão acessíveis?

2.3. Organização dos Requisitos

Uma vez que os requisitos tenham sido levantados, cabe agora organizá-los em grupos
correlacionados, de forma a abordá-los nos ciclos iterativos. Os requisitos podem ser agrupados do
seguinte modo [WAZ 04]:
a) Casos de uso. Os principais processos de negócio da empresa (casos de uso)
possivelmente terão um número considerável de requisitos funcionais.

b) Conceitos. Os conceitos envolvidos com o sistema possivelmente sofrerão operações

de manutenção ou cadastro. Em geral, essas operações são: inserir alterar, remover e
consultar. Nem sempre essas operações de manutenção de informações vão aparecer
nos casos de uso, e nem é necessário que isso aconteça. Basta definir quais são os
conceitos (informações) que devem sofrer manutenção e indicar a implementação das
operações de cadastro.

c) Consultas. O termo “consulta” refere-se tanto a consultas exibidas em tela quanto a

relatórios impressos.

2.4. Organização dos Requisitos em Casos de Usos

Segunda Wazlawick [WAZ 04] na fase de concepção é necessário identificar os grandes
processos da empresa. As operações elementares (consultas e alterações de dados) possivelmente
estarão inseridas dentro desses processos. Por exemplo, no caso de um sistema para videolocadora,
os grandes processos são: “fazer empréstimo de fitas”, “fazer devolução de fitas”, “fazer reservas”
etc.
Os grandes processos de negócio da empresa são também considerados casos de uso. Eles
devem cobrir as principais atividades da empresa ligadas ao sistema que será implementado. Cada
caso de uso deve estar associado a um conjunto de requisitos funcionais do sistema. Na fase de
concepção, os casos de uso só precisam ser listados, e eventualmente descritos em alto nível. Além
disso, ainda interessante indicar os atores envolvidos e os requisitos correlacionados.
Existe um diagrama na UML (Unified Modeling Language) para representar casos de uso e
seus atores. A principal utilidade desse diagrama é a capacidade de associar um conjunto de outros
artefatos que representam a interação entre os atores e o sistema. A Figura 2.3 representa um
diagrama de casos de uso para o sistema locadora.

Figura 2.3. Diagrama de casos de uso da UML.

 14
2.5. Organização dos Requisitos em Funções de Conceitos
Algumas operações relativamente simples e elementares (de um único passo), como o registro
de um fita ou de um pagamento, não devem ser consideradas casos de uso por si só, pois não há
necessidade de estudar seu processo iterativo, que é um único passo [WAZ 04].
Além disso, essas operações elementares possivelmente poderão fazer parte de algum caso de
uso propriamente dito. Por exemplo, o cadastro de uma fita fará parte do caso de uso de compra de
fitas, e o registro do pagamento de uma locação fará parte do caso de devolução de fitas.
Para identificar corretamente essas operações sem o ônus de incluí-las em um caso de uso
arbitrário, sugere-se que o projetista procure elaborar um modelo conceitual preliminar na fase de
concepção. Assim, será apenas indicado que esse modelo deve conter os conceitos e associações
que constituem a informação a ser armazenada pelo sistema. A Figura 2.4 apresenta um modelo
conceitual simplificado para o problema de videolocadora.

Figura 2.4. Um modelo conceitual preliminar para a videolocadora Fonte: Wazlawick [WAZ 04].

Nessa fase, basta ao projetista saber que os conceitos identificados são informações
localizadas nos textos do documento de requisitos.
As associações, por sua vez, são ligações estruturais entre conceitos, que complementam a
informação registrada por eles.
Uma vez identificados os conceitos principais, pode-se definir uma tabela que indicará se eles
devem sofrer inserção ( I ), alteração ( A ), exclusão ( E ) ou consulta ( C ). Pode-se construir uma
tabela para indicar os conceitos e quais operações serão possíveis sobre eles (Figura 2.5). Nessa
tabela, também é possível identificar restrições ou regras de validação para a execução das
operações. Por exemplo, “um cliente só pode ser excluído se não houver nenhum empréstimo
alocado a ele”.
 15
Conceito I A E C Observação Ref. Cruzada
Cliente Só é possível excluir se não houver F13
X X X X
empréstimos associados.
Reserva F15, F16
X X X X

Fita Só é possível excluir se não houver F18

X X X X
empréstimos associados.
Empréstimo A inclusão de empréstimo só pode acontecer F17, F19
através do caso de uso “emprestar fitas”.
X X
Não é possível alterar um empréstimo, apenas
excluir.
Figura 2.5. Listagem de conceitos e operações de manutenção (Fonte: Wazlawick [WAZ 04]).

2.6. Elaboração
A fase de elaboração inclui a comunicação com o cliente e atividades de modelagem do
modelo genérico de processo. A elaboração refina e expande os casos de uso preliminares que
foram desenvolvidos como parte da fase de concepção e expande a representação arquitetural para
incluir cinco visões diferentes do software - o modelo de casos de uso, o modelo de análise, o
modelo de projeto, o modelo de implementação e o modelo de implantação. Em alguns casos, a
elaboração cria uma "referência arquitetural executável" que representa uma primeira versão do
sistema executável [WAZ 04]. A referência arquitetural demonstra a viabilidade da arquitetura,
mas não fornece todas as características e funções requeridas para uso do sistema. Além disso, o
plano é cuidadosamente revisto no ápice da fase de elaboração para garantir que o escopo, os
riscos e as datas de entrega permaneçam razoáveis. As modificações no plano podem ser feitas
nessa etapa [PRE 06].

2.7. Construção
A fase de construção é idêntica à atividade de construção definida para o processo genérico de
software. Usando o modelo arquitetural como entrada, a fase de construção desenvolve ou adquire
os componentes de software que vão tornar cada caso de uso operacional para os usuários finais.
Para conseguir isso, os modelos de análise e projeto que foram iniciados durante a fase de
elaboração são completados de modo a refletir a versão final do incremento de software. Todas as
características e funções necessárias e requeridas do incremento de software (isto é, a versão)
serão implementadas no código-fonte. À medida que os componentes são implementados, testes
unitários são projetados e executados para cada um deles. Além disso, as atividades de integração
(montagem de componentes e testes de integração) são conduzidas. Casos de uso são usados para
derivar uma seqüência de testes de aceitação que serão executados antes do início da fase seguinte
do RUP [PRE 06].

2.8. Transição
Segundo Pressman [PRE 06], a fase de transição do PU abrange os últimos estágios da
atividade genérica de construção e a primeira parte da atividade genérica de implantação. O
software é dado aos usuários finais para teste beta e relatórios de feedback do usuário sobre
defeitos e modificações necessárias. Além disso, a equipe de software cria as informações de
apoio necessárias (por exemplo, manuais de usuário, guias de solução de problemas e
procedimentos de instalação) que precisam ser entregues. Na conclusão da fase de transição, o
incremento de software torna-se uma versão utilizável do software (Figura 2.6).
 16

Fase de Concepção

Documento de visão
Modelo Inicial de Caso de Uso
Glossário Inicial do Projeto
Caso de negócio inicial do projeto
Plano de Projeto – fases e iterações

Fase de Elaboração

Modelo de caso de uso

Modelo de análise
Descrição da arquitetura de software
Modelo de projeto (preliminar)
Manual do usuário (preliminar)

Fase de construção

Modelo de projeto
Componentes do software
Plano de procedimento de teste
Caso de teste
Manuais (de instalação, do sistema)

Fase de transição

Incremento do software entregue

Relatório de teste
Realimentação geral usuário

Figura 2.6. Principais produtos de trabalho (artefatos) produzidos em cada fase do RUP. Fonte:
Pressman [PRE 06].
 17

 SQL – Structure Query Language

Structured Query Language, ou Linguagem de Consulta Estruturada ou SQL, é uma
linguagem de pesquisa declarativa para banco de dados relacional (bases de dados relacionais).
Muitas das características originais do SQL foram inspiradas na álgebra relacional.
A SQL é uma linguagem padrão de consulta em banco de dados. Isto decorre da sua
simplicidade e facilidade de uso. Ela se opõe a outras linguagens, no sentido em que uma consulta
SQL especifica a forma do resultado e não o caminho para chegar a ele. Desta forma, a SQL é uma
linguagem declarativa em oposição a outras linguagens procedurais. Isto reduz o ciclo de
aprendizado daqueles que se iniciam na linguagem.
Embora a SQL tenha sido originalmente criado pela IBM, rapidamente surgiram vários
"dialetos" desenvolvidos por outras empresas de software. Essa expansão levou à necessidade de ser
criado e adaptado um padrão para a linguagem. Esta tarefa foi realizada pela American National
Standards Institute (ANSI) em 1986 e ISO em 1987.
A SQL foi revisada em 1992, recebendo o nome esta versão foi dado o nome de SQL-92. Foi
revisada novamente em 1999 e 2003 para se tornar SQL:1999 (SQL3) e SQL:2003,
respectivamente. A revisão SQL:1999 usa expressões regulares de emparelhamento, queries
recursivas e gatilhos (triggers). A SQL:2003 introduz características relacionadas ao XML,
seqüências padronizadas e colunas com valores de auto-generalização (inclusive colunas-
identidade).
Tal como dito anteriormente, a SQL embora padronizada pela ANSI e ISO, possui muitas
variações e extensões produzidos pelos diferentes fabricantes de sistemas gerenciadores de banco de
dados. Tipicamente a linguagem pode ser migrada de plataforma para plataforma sem mudanças
estruturais principais.
A SQL permite comunicar-se com o servidor e tem as seguintes vantagens:
 Eficiência;
 Facilidade de aprendizagem e uso;
 Funcionalidade completa (A SQL permite definir, recuperar e manipular dados das
tabelas.);

SELECT nome,
salario
FROM empregado;

Banco de
Nome Salario Dados
--------- -----------
JOAO 5000
JOSE 2500
PEDRO 4567

Figura 2.1. Comunicação da SQL com o banco de dados.

 18
3.1. Sobre PL/SQL
O A PL/SQL (Procedural Language/Structured Query Language) é uma linguagem
desenvolvida pela Oracle, que oferece funções para manipulação e recuperação de dados,
estendendo o padrão SQL. Além disso, a PL/SQL permite a construção de rotinas como
procedimentos e funções definidas pelo usuário, que são responsáveis pela manutenção de um
banco de dados.

3.2. Instruções SQL

O Oracle SQL é compatível com os padrões aceitos pela indústria. A Oracle Corporation
garante a compatibilidade com padrões em desenvolvimento, envolvendo ativamente uma equipe-
chave nos comitês de padrões SQL. Os comitês aceitos pela indústria são o ANSI e o ISO aceitaram
o SQL como a linguagem padrão para os bancos de dados relacionais.

Instrução Descrição
SELECT Recupera dados do banco de
dados.
INSERT Informa novas linhas, altera
UPDATE linhas existentes e remove
DELETE linhas indesejáveis de tabelas
do banco de dados,
respectivamente. O conjunto
dessas instruções é conhecido
como DML (Data Manipulation
Language).
CREATE Configura, altera e remove
ALTER estruturas de dados de tabelas.
DROP O conjunto dessas instruções é
RENAME conhecido como DDL (Data
TRUNCATE Definition Language).
COMMIT Gerencia as alterações feitas
ROLLBACK pelas instruções DML. É possível
SAVEPOINT agrupar as alterações dos dados
em transações lógicas (Controle
de transação).
GRANT Fornece ou remove direitos de
REVOKE acesso ao banco de dados Oracle
e às estruturas contidas nele. O
conjunto dessas instruções é
conhecido como DCL (Data Control
Language).
 19

 Oracle 11g – Express Edition – Uma visão geral do SGBD

Neste capítulo será feita a instalação do Oracle11g XE e a configuração de senha e usuário.
Após a instalação o usuário terá o nome system com a senha aluno. Isto permitirá um acesso mais
fácil no banco de dados, onde o instrutor do curso pode ter um controle mais fácil do andamento das
aulas.
O Oracle11g é um versão do SGBD Oracle totalmente gratuita, e oferece liberdade para
implementar aplicativos em muitas plataformas, tendo suporte para uma grande variedade de
ambientes de desenvolvimento. Muitos desenvolvedores de diversas plataformas, incluindo
estudantes e fornecedores de soluções de software, usam o Oracle11g sem qualquer custo. Isto é
possível através de download na página http://www.oracle.com fornecida pela própria Oracle.
Segundo Serson e Rezende [SER e REZ 06], o Oracle XE traz recursos de performance,
confiabilidade e segurança da versão 2 do Oracle11g, pois foi construído sobre a mesma base de
código. Por ser compatível com toda a família de produtos Oracle, ele permite aos usuários a
facilidade de começar com uma solução básica e ir mudando para outras versões quando necessário.
Permite ainda que os desenvolvedores tirem proveito do Oracle Application Express para rápido
desenvolvimento e implementação de aplicativos baseados na Web.
O ambiente do Oracle11g XE é acessado através do browser disponível no sistema
operacional do desenvolvedor, ou seja, para usar as ferramentas disponíveis no banco de dados é
necessário navegar pelas páginas do Oracle11g XE (Figura 4.1, Figura 4.2, Figura 4.3 e Figura 4.4).
Para manipulação e manutenção de um banco de dados Oracle, existem várias ferramentas e
aplicativos no mercado. Durante este curso será mostrado algumas ferramentas para a manutenção e
acesso a dados, como por exemplo, a ferramenta SQLDeveloper (Figura 4.5).

4.1. Limitações do Oracle11g

 Memória: até 1GB;

 Storage: até 4GB de dados para aplicações dos usuários;

 Processador: 1 processador, independente do tipo – Intel, etc...

 Plataforma: disponível para Windows de 32 bits e uma grande variedade de sistemas

operacionais Linux, incluindo Mandriva Linux 2006 Power Back+, SUSE Linux
Enterprise Server 9, SUSE Linux 10 da Novell, Red Hat Enterprise Linux 4, Fedora e
Ububtu [SER e REZ 06].

Figura 4.2. Funcionalidades existentes após execução

do Login.

Figura 4.1. Tela de Login do Oracle 11g XE.

 20

Figura 4.4. Exemplo do resultado de uma consulta

SQL através do uso da opção SQL Commands
mostrado na Figura 4.3.
Figura 4.3. Tela para execução de comandos
SQL.

Figura 4.5. Tela inicial do SQLDeveloper.

 21

 Tabelas usadas no Curso

5.1. Diagrama de Entidades-Relacionamento

CARG O DTNASC
NOME

(0,1) gerente
GERENCIA
EMPREGADO
(1,N)
gerenciado

SALARIO
NUEMP

G ERENTE

(1,N)
COMISSÃO

FAIXASALARIAL
LOTACAO

(1,1)
CODFAIXA
MENORSALARIO MAIORSALARIO
DEPARTAMENTO

NUDEPT
NOMEDEPT LOCALIZACAO

Figura 4.1. Diagrama de Entidades e Relacionamentos usado para modelar as tabelas do curso.

5.2. M odelo Físico das tabelas usadas no Curso

Figura 4.2. Modelo Físico das tabelas usadas para o curso.

 22

5.3. Executando o Script de Criação das tabelas usadas no curso

Execute o script de criação das tabelas usadas no curso seguindo os passos abaixo:

 Verifique se existe o arquivo tabelas_curso.sql na raiz da unidade C: ;

 Acesse o botão Iniciar  Programas  Oracle Database 11g Express Edition 

Executar Linha de Comandos SQL ;

 Faça a conexão usando o seguinte comando: conn system/aluno ;

 Para executar qualquer script no Oracle, basta digitar o arroba (@) antes do caminho
onde se encontra o arquivo contendo os comandos. No nosso caso, basta digitar:

@c:\tabelas_curso.sql  (ENTER)
 23

 Instruções Básicas da linguagem SQL

Para extrair dados do banco de dados, é preciso usar a instrução SELECT SQL. Talvez seja
necessário restringir colunas, evitar linha repetidas, usar operadores aritméticos, parênteses, nomear
colunas ou até mesmo concatená-las.
Neste capítulo iremos estudar as diversas formas de uso da instrução SELECT e sua interação
com o nosso ambiente de trabalho.

6.1. Os principais recursos das Instruções SELECT SQL

Para fazer o retorno de dados através da instrução SELECT SQL, é necessário fazer o
seguinte:

Seleção: É possível usar o recurso de seleção para selecionar as linhas de uma tabela que desejamos
ver o resultado. Além disso, podemos usar várias condições para restringir e selecionar as linhas.

Projeção: É possível usar o recurso de projeção para escolher as colunas as quais desejamos ver o
retorno na consulta.

Junção: É possível usar o recurso de junção para reunir vários dados armazenados em outras
tabelas diferentes, consolidando um vínculo entre os dados.

6.2. Facilitando a leitura das colunas – Exibindo a estrutura das tabelas

Usando os aplicativos disponíveis para manipular o banco de dados Oracle, é possível exibir
as estruturas das tabelas de um sistema. Através do comando DESC[RIBE] nome da tabela,
onde a digitação de todo o nome do comando é opcional, torna-se possível a listagem da estrutura
de uma tabela.

6.3. A sintaxe básica da instrução SELECT

SELECT [DISTINCT] *, COLUNA [ALIAS], COLUNA_2 [ALIAS], ...
FROM TABELA;

A sintaxe desta da seleção de dados permite que a na cláusula SELECT especifique as colunas
a serem exibidas. Já na cláusula FROM, é especificada a tabela que contém as colunas relacionadas
na cláusula SELECT.
De acordo com a sintaxe podemos definir:
 SELECT  É uma projeção de uma ou mais colunas.

 DISTINCT  Serve para suprimir as linhas duplicadas.

 *  Seleciona todas as colunas das tabelas envolvidas na cláusula FROM.

 COLUNA  Faz a projeção da coluna nomeada.

 ALIAS  Fornece os nomes dos cabeçalhos referentes às colunas projetadas.

 FROM TABELA  Determina a tabela contendo os dados e as colunas da cláusula

SELECT.
 24
É importante esclarecer que existem diferenças entre palavras-chave, cláusula e instrução. Como
por exemplo:

 A palavra-chave refere-se a um elemento SQL individual. SELECT e FROM.

 Uma cláusula é parte de uma instrução SQL. SELECT numdept, nomedept...

 Uma instrução é uma combinação de duas ou mais cláusulas.

6.4. Selecionando todas as colunas de uma tabela

Para exibir todas as colunas de dados de uma tabela, simplesmente digite asterisco ( * ) após a
cláusula SELECT.

SELECT * FROM DEPARTAMENTO;

6.5. Especificando a seleção de Colunas

Como já foi visto no item 6.4 é possível selecionar colunas especificando seus nomes. O
exemplo abaixo demonstra esta situação.

SELECT NUMDEPT, NOMEDEPT FROM DEPARTAMENTO;

6.6. O uso de expressões aritméticas

No Oracle11g XE, é possível modificar a forma de exibição dos dados, efetuando cálculos ou
consultando cenários. Através das expressões aritméticas, nós podemos utilizar os nomes das
colunas que armazenam valores numéricos.

SELECT NUMEMP, NOME, GERENTE, SALARIO * 3 FROM EMPREGADO;

Os operadores aritméticos são representados da seguinte forma:

( + )  Adição, ( - )  Subtração, ( * )  Multiplicação e ( / )  Divisão.

Além disso, existe a precedência do uso de operadores aritméticos nas instruções SELECT.
No exemplo abaixo, é calculada a remuneração anual multiplicando 10 pelo salário mensal, mais
um adicional de R$ 300,00. Executando a instrução, observamos que a multiplicação será realizada
antes da adição.

SELECT NUMEMP, NOME, GERENTE, SALARIO, SALARIO * 10+300 FROM

EMPREGADO;

Caso seja necessário, use os parênteses para reforçar a ordem de precedência padrão e
aumentar a compreensão. Por exemplo, a expressão acima poderia ser criada utilizando (10 *
SALARIO) + 300, sem que haja alteração no retorno dos dados. Outro exemplo, seria somar R$
300, 00 ao salário, e em seguida multiplicar por 10. Observe a instrução abaixo:

SELECT NUMEMP, NOME, GERENTE, SALARIO, 10 * (SALARIO+300) FROM

EMPREGADO;
 25
6.7. O valor nulo na instrução SELECT SQL
O valor nulo não é zero e nem espaço em branco. Quando faltar valor de dados em uma linha
de uma determinada coluna, quer dizer que esse valor é nulo ou contém nulo. É bom destacar que as
colunas de qualquer tipo de dados podem ter valores nulos. Mas, caso a coluna da tabela tenha sido
criada com uma restrição NOT NULL ou como chave primária (PRIMARY KEY), torna-se
impossível a falta de valores, ou seja, a existência de valor nulo. Um exemplo do retorno de valores
nulo, é a seleção da coluna COMISSAO da tabela EMPREGADO:

SELECT NOME, DTNASC, COMISSAO FROM EMPREGADO;

6.8. Nomeando colunas através de apelidos

A nomeação de colunas através de apelidos é útil para fins de cálculos, ou simplesmente para
renomear uma coluna. Para renomear uma coluna utiliza-se imediatamente após o nome da coluna a
palavra-chave AS, entre o nome da coluna e o apelido.

NOTA
O uso do AS é opcional entre o nome da coluna e o apelido.

Caso o apelido tenha espaços ou caracteres especiais, usando inclusive letras maiúsculas e
minúsculas, é necessário o uso de aspas.
Os exemplos a seguir mostram a construção de instruções SELECT com o uso de apelidos.

SELECT NOME AS NOME_EMPREGADO, DTNASC DATA_NASCIMENTO, COMISSAO

FROM EMPREGADO;

SELECT NOME AS “Nome do Empregado”, ROUND(SYSDATE-DTNASC) AS

“Idade do Empregado” FROM EMPREGADO;

6.9. Concatenando colunas

Um recuso bastante útil para a construção de instruções SELECT no Oracle, é o uso de
concatenção de valores, colunas ou strings de caracteres.
A representação do operador de concatenação é através de duas barras ( || ). O resultado de
uma concatenção é uma coluna contendo uma expressão de caracteres. O exemplo a seguir mostra o
uso do operador de concatenação no Oracle11g XE:

SELECT NOME|| '-'||CARGO AS “Nome-Cargo do Empregado” FROM

EMPREGADO;

SELECT NOME||CARGO NOMECARGO FROM EMPREGADO;

6.10. Eliminação de Linhas Duplicadas

Para eliminar linhas repetidas de um resultado, basta incluir a palavra-chave DISTINCT na
cláusula SELECT da instrução. Como por exemplo, caso seja necessário listar todos os
departamentos e cargos existentes na tabela empregado (Figura 6.1).

SELECT NUMDEPT, CARGO FROM EMPREGADO;

Com o uso da palavra-chave DISTINCT, o resultado é a eliminação das linhas duplicadas para
cada código de departamento (Figura 6.2).

SELECT DISTINCT NUMDEPT, CARGO FROM EMPREGADO;

 26

Figura 6.1. Resultado de uma instrução SELECT sem o uso do DISTINCT.

Figura 6.2. Resultado de uma instrução SELECT com o uso do DISTINCT.

6.11. Exercícios
1) Verifique se as instruções abaixo estão corretas ( C ) ou incorretas ( I ):

a. SELECT NOME, GERENTE FROM AS EMPREGADO; ( ).

b. SELECT NOME, GERENTE AS “MEU GeReNtE” FROM EMPREGADO ; ( ).

c. SELECT SALMENOR*12 AS Multiplica por 12 FROM EMPREGADO; (

).

2) Verifique se há erros na instrução abaixo. Se houver refaça a instrução corretamente:

SELECT NUMEMP, NOME SALARIO*6 Salário Semestral EMPREGADO;

3) Mostre a estrutura da tabela FAIXASALARIAL e em seguida mostre todos os seus dados.

 27

4) Mostre a estrutura da tabela EMPREGADO. Crie uma consulta para listar o nome, o cargo,
a data de admissão e o número do empregado. O nome do empregado deverá aparecer
primeiro. Salve esta consulta com o nome exer6_11.sql, dentro da raiz da unidade C:.

5) Execute a consulta salva no exercício 4.

6) Crie uma consulta para exibir os cargos (de forma exclusiva) a apatir da tabela
EMPREGADO.

7) Concatene o nome do empregado com o seu cargo. A concatenação deve considerar uma
vírgula e um espção entre as colunas selecionadas. Nomeie a coluna como “Nome e Cargo
do Emp.”.

8) Crie uma consulta para exibir todos os dados da tabela EMPREGADO. Separe as colunas
por vírgula e nomeie a coluna como SAIDA_EMPREGADO.
 28

 Limitando e classificando as linhas recuperadas

A limitação de linhas é usada em uma instrução SELECT SQL para recuperar determinadas
linhas de dados existentes em uma tabela. Por exemplo, caso seja necessário consultar todos os
códigos das faixas salariais que se encontram entre 400 e 5000. Outro exemplo seria a seleção de
todos os empregados que tem o departamento localizado em Belo Horizonte.
A classificação dos dados permite que as linhas sejam retornadas em uma determinada ordem.
Como por exemplo, o retorno do somatório dos salários por departamento, sendo a ordenação
(classificação) por nome de departamento.
Neste capítulo serão vistos os principais recursos de limitação do retorno de linhas de dados
oferecidos pelo Oracle11g XE.

7.1. Limitando o retorno de linhas

É possível limitar as linhas retornadas da consulta utilizando a cláusula WHERE. Uma
cláusula WHERE contém uma condição que deve coincidir e seguir diretamente a cláusula FROM.
A sintaxe da cláusula WHERE é a seguinte:

WHERE limita a consulta de linhas que atendem uma condição.

Condição ou condições pode ser composta por nomes de colunas, expressões,

constantes e operadores de comparação.

Usando a cláusula WHERE é possível fazer a comparação de valores em colunas, valores

texto, expressões artméticas, funções oferecidas pelo Oracle11g XE, ou funções definidas pelo
usuário. A cláusula WHERE é formada por três elementos:

 Nome da coluna;
 Operadores de comparação;
 Nome da coluna, constante ou lista de valores.

Abaixo seguem alguns exemplos do uso da cláusula WHERE, com algumas considerações.

SELECT NUMEMP, NOME FROM EMPREGADO WHERE CARGO=‘CONTADOR’;

No exemplo acima, a instrução SELECT recupera o número e o nome dos empregado cujo o
cargo é igual a CONTADOR. Observe que o cargo CONTADOR foi especificado em letras
maiúsculas para garantir que a correspondência seja feita com a coluna do cargo existente na tabela
EMPREGADO.

SELECT NOME, SALARIO FROM EMPREGADO WHERE SALARIO >= 2100;

No exemplo acima, a instrução SELECT recupera o nome e o salário dos empregado que tem
o salário maior ou igual a R$ 2.100,00. Observe que o valor comparado na cláusula WHERE não
precisou de aspas ( >=2100 ), pelo fato de ser do tipo numérico.

No Oracle as strings de caractere e valores de data aparecem entre aspas simples. Os valores
de caractere fazem distinção entre maiúsculas e minúsculas e os valores de data diferenciam
formatos. Além disso, o formato de data padrão é DD-MES-AA (01-JAN-07).
Os produtos da Oracle armazenam datas em um formato numérico interno, representando o
século, ano, mês, dia, horas, minutos e segundos.
 29
7.2. Trabalhando com operadores de comparação
Os operadores de comparação são usados na cláusula WHERE através da seguinte sintaxe:

SELECT COLUNA FROM TABELA WHERE EXPRESSAO VALOR OPERADOR.

Abaixo seguem alguns exemplos:

SELECT ... FROM ... WHERE DATANASC = ‘10-FEB-70’

SELECT ... FROM ... WHERE SALARIO = 5000
SELECT ... FROM ... WHERE CARGO <> ‘GERENTE’

A tabela abaixo mostra os operadores de comparação usados pelo Oracle11g.

Operador Significado
= Igual a
> Maior do que
>= Maior do que ou igual a
< Menor do que
<= Menor ou igual a
<> Diferente de

O exemplo a seguir complementa a explicação sobre operadores de comparação:

SELECT NOME, SALARIO, COMISSAO FROM EMPREGADO WHERE SALARIO<=1200;

O banco de dados Oracle11g oferece outros tipos de operadores de comparação. A listagem

abaixo mostra estes operadores;

 BETWEEN ... AND ...  Significa entre dois valores (inclusive).

 IN (lista de valores)  Associa qualquer um de uma lista de valores.

 LIKE  Associa um padrão de caractere.

 IS NULL  Faz uma comparação para saber se é valor nulo.

Os exemplos a seguir mostram o uso destes operadores.

BETWEEN

SELECT NOME, SALARIO FROM EMPREGADO WHERE SALARIO BETWEEN 200 AND
2000;

No exemplo acima, a instrução SELECT retorna as linhas da tabela EMPREGADO para

qualquer empregado cujo salário esteja entre 200 e 2000 inclusive.

IN

SELECT NUMEMP, NOME, SALARIO, GERENTE WHERE GERENTE IN (3, 4, 5);

 30

No exemplo acima, o número, nome, o salário e o código de gerente de todos os empregados

são listados, onde o código do gerente deve ser 3, 4 ou 5.

LIKE

SELECT NOME FROM EMPREGADO WHERE NOME LIKE ‘EV%’;

A instrução SELECT acima retorna o nome do empregado da tabela de EMPREGADO, para

qualquer empregado cujo o nome começa com ‘EV’.
O operador LIKE pode ser usado como um atalho para algumas comparações BETWEEN. O
exemplo a seguir exibe os códigos e as data de nascimento de todos os empregados nascidos entre
janeiro e dezembro de 1970:

SELECT NUMEMP, DTNASC FROM EMPREGADO WHERE DTNASC LIKE ‘%1970’;

Além do símbolo de percentual, existem o símbolo que representa um caractere único para
ser usado com o operador LIKE. Segue uma tabela explicando os dois caracteres:

Símbolo Descrição
% Representa qualquer seqüência de zero ou mais caracteres.

_ Representa qualquer caractere único.

O exemplo abaixo mostra o uso dos dois símbolos do operador LIKE:

SELECT NOME FROM EMPREGADO WHERE NOME LIKE ‘_B%’;

Além destes símbolos usados no operador LIKE existe a opção de ESCAPE. Quando for
necessário ter uma correspondência exata para os caracteres ‘%’ e ‘_’, use a opção ESCAPE. Como
exemplo, caso a localização do departamento onde os empregados estão lotados tenha no nome o
símbolo ‘_’, como DEPARTAMENTO_VENDAS, a seguinte instrução deve ser usada:

SELECT * FROM DEPARTAMENTO WHERE NOMEDEPT LIKE ‘%\_’ ESCAPE ‘\’;

A barra invertida é o escape, identificado pela opção ESCAPE.

IS NULL

O operador IS NULL testa os valores que são nulos. Um valor nulo significa que o valor não
está disponível, não-atribuído, desconhecido ou não-aplicável. Assim não é possível testar com o
sinal de igual, por que um valor nulo não pode ser igual ou diferente a qualquer valor.
O exemplo abaixo recupera o nome e o código de gerente de todos os empregados que não
possuem gerentes.

SELECT NOME, GERENTE FROM EMPREGADO WHERE GERENTE IS NULL;

7.3. Trabalhando com operadores lógicos

Um operador lógico combina o resultado de duas condições para produzir um único resultado
com base neles ou inverter o resultado para uma condição única. Os três operadores lógicos
existente no Oracle11g são: AND, OR e NOT.
 31
A seguir são listados exemplos do uso dos operadores lógicos:
AND

SELECT NUMEMP, NOME, CARGO, SALARIO FROM EMPREGADO WHERE

SALARIO>=1300 AND CARGO <> ‘TRAINEE’;

No exemplo acima, o uso do AND exige que as duas condições sejam verdadeiras, ou seja, só
será listado o registro que conseguir satisfazer as duas condições.

OR

SELECT NUMEMP, NOME, CARGO, SALARIO FROM EMPREGADO WHERE

SALARIO>=1300 OR CARGO <> ‘TRAINEE’;

No exemplo acima, o uso do OR exige apenas uma das condições seja verdadeira, ou seja, só
será listado o registro que conseguir satisfazer uma das duas condições.

NOT

SELECT NUMEMP, NOME, CARGO, SALARIO FROM EMPREGADO WHERE GERENTE

NOT IN (2, 4, 5);

No exemplo acima, o uso do NOT faz com que sejam listados o número, nome, cargo e o
salário de todos os empregados que não tenham os gerentes com o código 2, 4 ou 5.

NOTA
O operador NOT pode ser utilizado também com outros operadores SQL:
SELECT ... FROM ... WHERE CARGO NOT IN (‘GERENTE’, ‘CONTADOR’, ‘TRAINEE’);
SELECT ... FROM ... WHERE SALRIO NOT BETWEEN 2000 AND 2450;
SELECT ... FROM ... WHERE NOME NOT LIKE ‘A%’;
SELECT ... FROM ... WHERE COMISSAO IS NOT NULL;

NOTA
Regras de Precedência:
Ordem Operador
1 Todos os operadores de comparação
2 NOT
3 AND
4 OR
Caso seja necessário, sobreponha as regras de precedência usando parênteses.

7.4. A cláusula ORDER BY

Para classificação de linhas usa-se a cláusula ORDER BY. A classificação pode ser crescente
( ASC ) ou descendente ( DESC ). A cláusula ORDER BY vem depois da instrução SELECT,
sendo sempre colocada por último. Além disso, é possível especificar uma expressão ou um apelido
para a classificação. Abaixo segue um exemplo do uso do ORDER BY, onde os registros são
listados em ordem descrescente de data de nascimento:

SELECT NOME, CARGO, NUMDEPTO, DTNASC FROM EMPREGADO ORDER BY

DTNASC DESC;

Os próximos exemplos mostram o uso do ORDER BY através de um apelido de coluna, e

uma classificação usando várias colunas:
 32

SELECT NUMEMP, NOME, SALARIO * 6 SALARIOSEMESTRAL FROM EMPREGADO

ORDER BY SALARIOSEMESTRAL;

SELECT NOME, CARGO, NUMDEPTO, DTNASC FROM EMPREGADO ORDER BY

DTNASC, NOME;

NOTA
Quando não se usa a classificação ASC ou DESC da cláusula ORDER BY, é assumido ASC como padrão.

7.5. Exercícios
1) Crie uma consulta para exibir o nome, o cargo e o salario dos empregados que recebem mais
que R$ 1750,00. Salve esta consulta na raíz da unidade C:, com o nome de salario_1.sql.

2) Crie uma consulta que liste o número, o nome, o salário e o número do departamento, para o
número de empregado igual a 10.

3) Modifique a consulta salario_1.sql, para listar os empregados que tenham salários entre R$
450,00 e R$ 1.246,00. Em seguida execute a consulta.

4) Elabore uma consulta que liste o nome, o cargo e a data de nascimento, cuja data de
nascimento esteja entre 01 de janeiro de 1968 e 31 de janeiro de 1980, inclusive. Classifique a
consulta de modo descresente por data de nascimento.

5) Crie uma consulta que liste o nome do empregado e o número do departamento, onde os
empregados pertencem ao departamento 1 ou 3, por ordem alfabética de nome.

6) Crie uma consulta que liste a data de nascimento e o nome do empregado que nasceram em
1982.

7) Crie uma consulta que liste todos os campos da tabela empregado, para aqueles empregados
que não possuem gerente.

8) Crie uma consulta que liste todos os empregados que possuem comissão.
 33

 Trabalhando com Funções SQL no Oracle11g

As funções formam o bloco de consulta básico e são usadas para manipular valores de dados.
Neste capítulo serão abordadas as funções de caractere de uma única linha, de número e de datas.
Também serão mostradas as funções que convertem dados de um tipo para outro, por exemplo,
dado do tipo texto para dado do tipo numérico.
As funções oferecem recursos avançados e podem ser usadas para realizar a execução de
cálculos, modificações de itens de dados individuais, manipulação de grupos de linhas, formatação
de datas e números para exibição e conversão de tipos de dados.
Existem dois grupos de funções: as funções de uma única linha, e as funções de várias linhas.
O primeiro grupo de funções operam somente em linhas únicas e retornam um resultado por
linha. Este capítulo irá abordar as funções de única linha para caractere, número, data e conversão
de tipos de dados. O outro grupo de funções manipula grupos de linha a fim de obter um resultado
de um agrupamento de dados, como por exemplo, a soma e a média de valores.
As funções de única linha são usadas para manipular itens de dados, e aceitam um ou mais
parâmetros que retornam um valor para cada linha retornada pela consulta. Essas funções podem ser
usadas nas cláusulas SELECT, WHERE e ORDER BY.
Abaixo segue a sintaxe usada para manipulação de funções no Oracle:
 nome_da_função;
 coluna. É qualquer coluna do banco de dados nomeada;
 expressão. É qualquer string de caractere ou expressão calculada;
 arg1, arg2, arg3. É qualquer argumento a ser utilizado pela função.

8.1. Funções para manipulação de Caractere

As funções para manipulação de caractere de uma única linha, aceitam dados de caractere
como entrada e podem retornar valores de número e valores texto. As funções podem ser divididas
nas seguintes categorias:
 Funções de Conversão de Maiúsculas e Minúsculas;
 Funções de manipulação de texto.

Função de Caractere Objetivo da Função

LOWER (coluna ou expressão)
UPPER (coluna ou expressão)
INITCAP (coluna ou expressão)
CONCAT (coluna ou expressão ,
coluna2 ou expressão2)
Fazer a conversão de valores
texto (caractere) para letras
minúsculas.
Fazer a conversão de valores
texto (caractere) para letras
maiúsculas.
Fazer a conversão de valores
texto para usar a primeira letra
como maiúscula de cada palavra
existente na coluna ou
expressão.
Fazer a concatenação do primeiro
valor do caractere ao segundo
valor. Equivale ao “||”
 34

Função de Caractere Objetivo da Função

SUBSTR (coluna ou expressão, p
[numcat])
LENGTH (coluna ou expressão)
INSTR (coluna ou expressão,
caractere)
TRIM (elimina iniciais ou
posterior ou ambos. Sintaxe:
Caracter FROM coluna ou
expressão de origem)
Fazer o retorno de caracteres
específicos a partir do valor de
caractere começando na posição
p, até numcat caracteres depois.
Observação: Se p for negativo, a
conta inicia no final do valor
de caractere. Se numcat for
omitido, são retornados todos os
caracteres até o final da
string.
Fazer o retorno o número de
caracteres existentes na coluna
ou expressão.
Retornar a posição numérica do
caractere nomeado.
Fazer a eliminação dos
caracteres na posição mencionada
no parâmetro. Quando esses
caracteres não são mencionados,
a função TRIM limpa os espaços
em branco, tanto a esquerda
quanto à direita da coluna ou
expressão.

As expressões a seguir exemplificam o uso das funções para manipulação de caractere.

Função Saída
LOWER (‘CURSO ORACLE’) curso oracle
UPPER (‘Curso Oracle’) CURSO ORACLE
INITCAP (‘CURSO ORACLE’) Curso Oracle
CONCAT (‘CURSO’, ‘ORACLE’) CURSOORACLE
SUBSTR (‘CARACTERE’, 1, 2) CA
LENGTH (‘CARACTERE’) 9
INSTR (‘EVALDO’, ‘V’) 2
TRIM (‘E’ FROM ‘EVALDO’) VALDO

Abaixo seguem alguns exemplos de instruções SELECT com o uso das funções de caractere:

SELECT ‘O nome do cargo do ’||INITCAP(NOME)||‘ é ’||LOWER(cargo)

AS “Nome do cargo do Empregado” FROM EMPREGADO;

SELECT NUMEMP, INITCAP(NOME), NUMDEPT FROM EMPREGADO WHERE NOME =

UPPER(‘joao’);

SELECT NOME, CONCAT(NOME, CARGO), LENGTH(NOME), INSTR(NOME, ‘A’)

FROM EMPREGADO;

8.2. Funções para manipulação de tipos numéricos

As funções numéricas aceitam entrada numérica e retornam valores numéricos. Esta parte do
capítulo sobre funções descreve as funções numéricas encontradas no Oracle11g.
 35
Função Numérica Objetivo da Função
ROUND (coluna ou expressão, Fazer o arredondamento da
casas decimais) coluna, expressão ou valor para
o número de casas decimais
existente como parâmetro, ou se
este parâmetro for omitido,
neste caso não terá número de
casas decimais.
TRUNC (coluna ou expressão, “Truncar” a coluna, expressão ou
casas decimais) valor para o número de casas
decimais existente como
parâmetro, ou se este parâmetro
for omitido, neste caso não terá
número de casas decimais.
MOD (valor1, valor2) Retorna o resto de valor1
dividido por valor2.

As expressões a seguir exemplificam o uso das funções para manipulação de caractere.

Função Saída
ROUND (35.939, 2) 35,94
TRUNC (35.939,2) 35,93
MOD (1500, 200) 100

Abaixo seguem alguns exemplos de instruções SELECT com o uso das funções de caractere:

SELECT ROUND(35.939, 2), ROUND(35.939, 1), ROUND(35.939, -1) FROM

DUAL;

SELECT TRUNC(35.939, 2), TRUNC(35.939), TRUNC(35.939, -1) FROM

DUAL;

SELECT NOME, SALARIO, COMISSAO, MOD(SALARIO, COMISSAO) RESTANTE

FROM EMPREGADO WHERE CARGO = ‘VENDEDOR’;

8.3. Trabalhando com Datas no Oracle11g

O Oracle armazena datas em um formato numérico interno: século, ano, mês, dia, horas,
minutos, segundos.
O formato de data padrão é DD-MES-AA. Além disso, podemos usar a função SYSDATE,
usada para retornar a data e hora atual. Para visualizar o retorno da função SYSDATE, usa-se a
tabela DUAL. A tabela DUAL pertence ao usuário SYS e pode ser acessada por todos os usuários.
Ela contém uma coluna e uma linha. A tabela DUAL é útil quando desejamos retornar um valor
somente, por exemplo o valor de uma constante, pseudocoluna ou expressão que não é derivada de
uma tabela com dados do usuário. Abaixo segue um exemplo do uso do SYSDATE com a tabela
DUAL.

SELECT SYSDATE FROM DUAL;

8.4. Aritmética com Datas

Os banco de dados armazenam datas como valores numéricos, desta forma nós podemos
executar cálculos usando operadores artiméticos como adição e subtração. Além disso, é possível
adicionar e subtrair constantes de número assim como datas também.
 36
Podemos executar as seguintes operações:

Operação Retorno da operação Descrição

Data + número Data Adiciona um valor numérico de
dias para uma data.
Data – número Data Substrai um valor numérico de
dias de uma data.
Data – Data Número de dias Subtrai uma data da outra.
Data + número/24 Data Adiciona um número de horas
para uma data.

Abaixo segue um exemplo sobre aritmética com datas no Oracle:

SELECT NOME, (SYSDATE-DTNASC)/12 MESES FROM EMPREGADO WHERE

NUMDEPT = 2;

8.5. Funções de Data

Funções que operam e manipulam datas no Oracle retornam um valor de tipo de dados DATE
exceto a função MONTHS_BETWEEN. Abaixo segue um resumo sobre estes tipos de funções.

Função Descrição

MONTHS_BETWEEN Número de meses entre duas datas

ADD_MONTHS Adiciona meses de calendário para a data

NEXT DAY
Dia seguinte da data especificada
-
LAST DAY Último dia do mês

ROUND Data de arredondamento

TRUNC Data para truncada

 MONTHS BETWEEN(data_l, data_2): Localiza o número de meses entre a data_1 e a data_2.

O resultado pode ser positivo ou negativo. Se data_1 for posterior a data_2, o resultado será
positivo; se a data_l for anterior a data_2, o resultado será negativo.

 ADD MONTHS(data, numero): Adiciona um número (numero) de meses de calendário à data.

O valor do parâmetro numero deve ser inteiro ou pode ser negativo.

 NEXT DAY(data, ´char´): Localiza a data do próximo dia especificado da data seguinte da
semana. O valor de char pode ser um número representando um dia ou uma string de caractere.

 LAST_DAY(data): Localiza a data do último dia do mês que contém a data.

 ROUND(data[,'formato']): Retorna a data arredondada para a unidade especificada pelo modelo

de formato estabelecido. Se o modelo de formato for omitido, a data será arredondada para o dia
mais próximo.

 TRUNC(data, ['formato']): Retorna a data com a parte da hora do dia truncada para a unidade
 37
especificada pelo modelo de formato. Se o modelo de formato for omitido, a data será truncada para
o dia mais próximo.

A seguir veremos alguns exemplos sobre o uso das funções de data existentes no Oracle:

Função Saída
MONTHS_BETWEEN (‘01-SEP-87’, ‘23-JAN-84’) 43,290
ADD_MONTHS(‘11-JAN-94’, 6) ‘11-JUL-94’
NEXT_DAY (‘08-MAR-07’, ‘SUNDAY’) ‘11-MAR-07’
LAST_DAY (‘10-FEB-07’) ‘28-FEB-07’
ROUND(‘06-JUL-95’, ‘MONTH’) 01-AUG-95
ROUND(‘06-JUL-95’, ‘YEAR’) 01-JAN-96
TRUNC(‘06-JUL-95’, ‘MONTH’) 01-JUL-95
TRUNC(‘06-JUL-95’, ‘YEAR’) 01-JAN-95

Abaixo segue um exemplo do uso de funções de data em instruções SQL:

SELECT NUMEMP
, DTNASC
, MONTHS_BETWEEN(SYSDATE, DTNASC)
, ADD_MONTHS(DTNASC, 6)
, NEXT_DAY(DTNASC, ‘SUNDAY’)
, LAST_DAY (DTNASC)
FROM EMPREGADO
WHERE MONTHS_BETWEEN(SYSDATE, DTNASC)>310;

SELECT NUMEMP
, DTNASC
, ROUND(DTNASC, ‘MONTH’)
, TRUNC (DTNASC, ‘MONTH’)
FROM EMPREGADO
WHERE DTNASC LIKE '20/02%';

8.6. Funções usadas para converter data ou valores numéricos

Além dos tipos de dados Oracle, as colunas de tabela em um banco de dados Oracle11g
podem ser definidas usando os tipos de dados ANSI.
Em alguns casos, o servidor de banco de dados Oracle aceita dados de um tipo de dados
diferente daquele existente na consulta ou uma outra instrução SQL. Isso é permitido quando Oracle
pode converter dados automaticamente para o tipo de dados esperado. Essa conversão de tipo de
dados pode ser realizada de forma explícita pelo usuário.
As conversões explícitas de tipo de dados podem ser realizadas usando-se as funções de
conversão. As funções de conversão convertem um valor de um tipo de dados para outro.
Geralmente, o formato dos nomes de função seguem a convenção tipodedado PARA tipodedado. O
primeiro tipo de dados é um tipo de dados de entrada; o último tipo de dados é de saída.

8.7. A função TO_CHAR

Nos exemplos anteriores, todos os valores de data no Oracle11g eram exibidos no formato
DD-MES-YY. A função TO_CHAR permite converter uma data a partir desse formato default para
um formato especificado por nós.
 38
Regras para uso da Função TO_CHAR

 formato deve estar entre aspas simples.

 formato pode incluir qualquer elemento de formato de data válido. Certifique-se de separar o
valor da data do formato por uma vírgula.
 Os nomes de dias e meses na saída são preenchidos automaticamente por espaços.

SELECT NOME, TO CHAR(DTNASC, 'MM/YY') AS “Mês e Ano de Nascimento”

FROM EMPREGADO WHERE
CARGO = 'CONTADOR';

8.8. Elementos dos Formatos de Data

Elemento Descricão
Retorna apenas o ano da data
Anos em datas YYYY
formatada.
Últimos três, dois ou um dígitos do
YYY ou YY ou Y
ano.
Y.YYY Ano com vírgula nesta posição.
Retorna o trimestre do ano da data
Q
formatada.
MM Mês, com valor de dois dígitos.
Nome do Mês preenchido com espaços
MONTH
limitado em nove caracteres.
Nome do mês, abreviação de três
MON
letras.
W W ou W Retorna a semana do ano ou mês.

DDD ou DD ou D Dia do ano, mês ou semana.

Retorna nome do dia preenchido com
DAY
espaços limitado a nove caracteres.
Nome do dia com abreviação de três
DY
letras.
Retorna as horas do dia ou hora (1 a
HH ou HH12 ou HH24
12) ou hora (0 a 23) da data formatada.
MI Minuto (0 a 59)

SS Segundo (0 a 59)
Segue abaixo alguns exemplos de instruções SELECT com o uso da função TO_CHAR na
formatação de datas.

Formato com Dia, Mês (Por Extenso) e Ano (Por Extenso)

SELECT TO_CHAR(SYSDATE, 'DD') DIA

, TO_CHAR(SYSDATE, 'MONTH') MES_EXTENSO
, TO_CHAR(SYSDATE, 'YEAR') ANO_EXTENSO
 39
FROM DUAL

Formato com Dia, Mês e Ano

SELECT TO_CHAR(SYSDATE, 'DD/MM/YYYY') DIA_MES_ANO FROM DUAL;

Nome completo do Dia

SELECT TO_CHAR(SYSDATE, 'DAY') DIA_MES_ANO FROM DUAL;

Formato de Dia, Mês, Ano e Hora

SELECT TO_CHAR(SYSDATE, 'DD/MM/YYYY HH24:MI:SS') DT_HR FROM DUAL;

Formato de Dia e Mês – Adicionando string de caractere

SELECT TO_CHAR(SYSDATE, 'DAY DD “do mês de” MONTH') DIA_MES FROM

DUAL;

8.9. O uso da função TO_CHAR formatando números

Usamos os formatos de representação numérica
valor de número como um caractere.
Para trabalharmos com valores de número tais
converter esse números para algum tipo de dados de
traduz o tipo de dados de NUMBER para tipo
particularmente útil com concatenação.
com a função TO_CHAR para exibir um
como strings de caractere, nós devemos
caracter usando a função TO_CHAR, que
de dados VARCHAR2. Essa técnica é

Exemplo do
Elemento Descrição Resultado
Formato
Posição numérica (número de 9s
9 determinam o tamanho 999999 1331
do exibição)

0 Exibe zeros à esquerda 099999 001331

$ Sinal de Dólar. $999999 $1331

L Símbolo da moeda local flutuante L.999999 FF1233

Ponto decimal na posição
. 999999.99 1331.00
especificada

, Vírgula na posição especificada 999,999 1,331

Coloca número negativos entre

PR 999999PR (1331)
parênteses.

Segue abaixo alguns exemplos de instruções SELECT com o uso da função TO_CHAR na
formatação de números.

Formato com o sinal de dólar.

SELECT TO_CHAR(1331, '$9999') DIA FROM DUAL;

 40

Formato com osímbolo da moeda local flutuante

SELECT TO_CHAR(1331, 'L9999') DIA FROM DUAL;

8.10. A função TO_NUMBER

A função TO_NUMBER converte um valor texto para um valor numérico. Ou seja, faz
conversão explícita de texto (tipo VARCHAR) para número (tipo NUMBER). O exemplo abaixo
mostra o uso desta função.

SELECT TO_NUMBER('787') DIA FROM DUAL;

8.11. A função TO_DATE

A função TO_DATE converte um valor texto para um valor Date. Ou seja, faz conversão
explícita de texto (tipo VARCHAR) para data (tipo DATE). Segue um exemplo com o uso da
função TO_DATE.

SELECT TO_DATE('01/01/2008 00:01:00', 'DD/MM/YYYY HH24:MI:SS')

DIA_PRIMEIRO FROM DUAL;

NOTA
A função TO_DATE usa os formatos existentes na função TO_CHAR para a formatação de data.

8.12. A função NVL

A função NVL converte um nulo um valor real. Os tipos de dados que podem ser usados são
data, caractere e número. Como exemplo, caso tenhamos nulo na coluna de COMISSÀO da tabela
de EMPREGADO, então a função NVL poderia ser usada da seguinte forma:

SELECT NOME AS “Nome do Empregado”, NVL(COMISSAO, 0) AS “Comissão

dos Vendedores” FROM EMPREGADO WHERE CARGO = ‘VENDEDOR’;

Observe que após a execução da consulta a comissão que tem o valor nulo aparece com zero,
que é o valor real formatado para a exibição.

NOTA
A sintaxe da função NVL é NVL(coluna_tipo, valor). Não é possível converter valores que não sejam do
mesmo tipo determinado pela coluna.

8.13. A função DECODE

A função DECODE facilita a condicionais realizando o trabalho de uma instrução CASE ou
IF-THEN-ELSE. Decodifica a expressão após compará-la a cada valor de pesquisa. Se a expressão
for a mesma da pesquisa, o resultado é retornado.
Se o valor padrão for omitido, será retornado um valor nulo onde um valor de pesquisa não
corresponde a quaisquer valores do resultado.
Abaixo seguem algumas consultas com o uso da função DECODE.

SELECT CARGO, SALARIO,DECODE(CARGO , 'VENDEDOR', SALARIO*1.2

, 'GERENTE', SALARIO*1.05
, 'CONTADOR', SALARIO*1.1
 41
, SALARIO) ATUALIZA_SALARIO
FROM EMPREGADO;

8.14. Aninhamento de Funções

O exemplo abaixo exibe as comissões dos vendedores, no formato de moeda local. Caso o
vendedor não tenha comissão, então a mesma é trocada pelo valor especificado na função NVL.

SELECT NOME, NVL(TO_CHAR(COMISSAO, 'L9999.99'), TO_CHAR(0,

'L99.99')) FROM EMPREGADO WHERE CARGO = 'VENDEDOR';

8.15. Exercícios
1) Crie uma consulta para a exibir a data atual, somando a esta data mais 5. Coloque um apelido
com o nome de DATA_VENCIMENTO.

2) Exiba o número do empregado, o nome, o salário e um rejuste salarial para 20% formatado
como número inteiro. Coloque um apelido na coluna do cálculo com o nome “Salário Reajustado”.
Salve a instrução SQL em um arquivo com o nome sal_reaj.sql, e em seguida execute a consulta.

3) Modifique a consulta sal_reaj.sql para adicionar uma coluna que subtrairá o salário antigo do
novo salário. Crie um apelido com o nome ACRESCIMO. Execute a consulta novamente.

4) Para cada empregado exiba o nome do mesmo e calcule o número de meses entre hoje e a data
de nascimento. Coloque um apelido na coluna com o nome de MESES_NASC. Ordene as linhas do
resultado por número de meses de nascimento. Arredonde para cima o número de meses para o
número inteiro mais próximo.

5) Crie uma consulta que produza as seguintes informações para cada empregado: (nome do
empregado) recebe o salário de ( atributo salario) mensalmente, mas deseja receber (salário com o
acréscimo de 10 por cento). Coloque um apelido qualquer para a coluna.

6) Crie uma consulta que exiba o nome do empregado com a primeira letra maiúscula e todas as
outras minúsculas, bem como o tamanho de seus nomes, para todos os empregados cujo nome
começa com letra J, M ou P. Coloque um nome para o apelido na coluna.

7) Faça uma consulta que exiba o nome, a data de nascimento e o dia da semana em que o
empregado nasceu. Coloque um apelido para a coluna com o nome DIA. Classifique os resultados
por dia da semana, inciando por Domingo.

8) Crie uma consulta que liste o nome, o cargo e o nível para todos os empregados com base no
conteúdo da coluna CARGO, conforme a tabela demosntrada abaixo:

Cargo Nível
PRESIDENTE NIVEL_1
GERENTE NIVEL_2
CONTADOR NIVEL_3
VENDEDOR NIVEL_4
 42

 Desenvolvendo consultas com exibição de dados de várias

tabelas
O objetivo deste capítulo é criar instruções SELECT para obter acesso aos dados a partir de
mais de uma tabela, usando junções ou relacionamentos entre as mesmas.
Ás vezes é necessário utilizar dados a partir de uma ou mais tabelas. No exemplo abaixo, o
esquema mostra uma relação a partir de duas tabelas separadas, e em seguida como ficaria a
projeção do relacionamento.

EMPREGADO
NUMEMP NOME NUMDEPT

DEPARTAMENTO
NUMDEPT NOMEDEPT

EMPREGADO_DEPARTAMENTO
NUMEMP NUMDEPT NOME NOMEDEPT

Observe que para produzir o relacionamento EMPREGADO_DEPARTAMENTO, é

necessário que vincular as tabelas através do atributo NUMDEPT.
Um relacionamento é um mecanismo usado para consultar dados a partir de uma ou mais
tabelas, onde uma condição para o relacionamento é criada na cláusula WHERE. As linhas de uma
tabela podem ser unidas às linhas de outra tabela de acordo com os valores comuns existentes nas
colunas correspondentes. Em geral, colunas de chave primária e chave estrangeira. Para listar dados
a partir de uma ou mais tabelas, nós podemos criar uma condição simples de relacionamento. A
sintaxe abaixo irá ajudar a respeito:

 tabela.coluna  Respresenta a tabela e a coluna a partir das quais

recupera-se os dados.

 tabela1.coluna = tabela2.coluna  É a condição que relaciona as tabelas.

Existem algumas regras para a criação de instruções SELECT com relacionamentos. Abaixo
seguem algumas regras:

 Ao criar uma instrução SELECT que relacione várias tabelas, nós antecedemos o nome da
coluna com o nome da tabela, com o objetivo de definir o acesso ao banco de dados.

 Caso apareça o mesmo nome da coluna em mais de uma tabela , o nome da coluna deve estar
prefixado com o nome da tabela.

 Para relacionar várias tabelas, é necessário um mínimo de condições de relacionamento.

NOTA
Um relacionamento pode gerar um produto cartesiano. Um produto cartesiano é formado quando uma
condição de relacionamento estiver omitida, ou uma condição de relacionamento estiver inválida, ou ainda
quando todas as linhas na primeira tabela estão unidas às linhas da segunda tabela. Para evitar um produto
cartesiano, sempre inclua uma condição de relacionamento válida na cláusula WHERE.
 43
Os relacionamentos podem ser idênticos, não idênticos, externos ou auto-relacionamentos.
Um relacionamento idêntico é quando os valores das colunas das tabelas envolvidas são iguais.
Com freqüência, esse relacionamento envolve complementos de chave primária e chave estrangeira.
Abaixo segue um exemplo de relacionamento idêntico:

SELECT EMPREGADO.NUMEMP
, EMPREGADO.NOME
, EMPREGADO.NUMDEPT
, DEPARTAMENTO.NUMDEPT
, DEPARTAMENTO.NOMEDEPT
FROM EMPREGADO
, DEPARTAMENTO
WHERE EMPREGADO.NUMDEPT = DEPARTAMENTO.NUMDEPT;

Além do relacionamento, é possível ter critérios para a cláusula WHERE. Por exemplo, para
listar o número do empregado, o nome e o número do departamento, cujo departamento seja igual a
VENDAS. Abaixo a instrução SELECT, exemplifica esta situação:

SELECT EMP.NUMEMP
, EMP.NOME
, EMP.NUMDEPT
FROM EMPREGADO EMP
, DEPARTAMENTO DEPT
WHERE EMP.NUMDEPT = DEPT.NUMDEPT AND DEPT.NOMEDEPT = 'VENDAS';

Os relacionamentos não-idênticos são construídos quando nenhuma coluna de uma tabela

corresponde diretamente a uma coluna da outra tabela. Como exemplo, podemos verificar o
relacionamento entre EMPREGADO e FAIXASALARIAL. Neste caso o relacionamento existe em
função da coluna SALARIO da tabela EMPREGADO está limitado entre a coluna
MENORSALARIO e a coluna MAIORSALARIO da tabela de FAIXASALARIAL.
Abaixo segue um exemplo de relacionamento não-idêntico:

SELECT EMP.NOME
, EMP.SALARIO
, FAIXA.CODFAIXA
FROM EMPREGADO EMP
, FAIXASALARIAL FAIXA
, DEPARTAMENTO DEPT
WHERE EMP.NUMDEPT = DEPT.NUMDEPT
AND EMP.SALARIO BETWEEN FAIXA.MENORSALARIO
AND FAIXA.MAIORSALARIO AND DEPT.NOMEDEPT = 'VENDAS';

Em vários momentos na manutenção de um banco de dados ou desenvolvimento de sistemas

de informação, é feita a união de uma tabela a ela mesma. Como por exemplo, para localizar o
nome do gerente de cada empregado, é necessário unir a tabela EMPREGADO a ela mesma ou
executar o auto-relacionamento. Como exemplo, podemos localizar o nome do gerente, cujo
número do empregado seja igual a 10. Neste caso o gerente seria o João.
Um relacionamento externo consiste da consulta de linhas que em geral não atendem à
condição de relacionamento, e neste caso é usado um sinal de adição (+). As linhas ausentes podem
ser retornadas se o operador de adição for utilizado no relacionamento, sendo colocado ao lado do
relacionamento que está com a informação insuficiente. Este operador possui o efeito de criar uma
ou mais linhas nulas para qual uma ou mais linhas da tabela não-deficiente pode ser unida. A
sintaxe abaixo mostra o uso dos relacionamentos externos:
 44

 tabela1.coluna = tabela2.coluna(+)  É o símbolo de junção externa colcoado em

qualquer lado da condição da cláusula WHERE. Não é possível colocar nos dois lados.

Por exemplo, se a tabela EMPREGADO não tiver empregados com o gerente, o

relacionamento externo com o uso do sinal de adição é colocado ao lado da relação do empregado
com gerente, ou seja, o atributo GERENTE. O exemplo abaixo mostra uma instrução SELECT com
o uso do relacionamento externo.

SELECT EMP_OPERACAO.NUMEMP
, EMP_OPERACAO.NOME
, EMP_GERENTE.NUMEMP
, EMP_GERENTE.NOME
FROM EMPREGADO EMP_OPERACAO
, EMPREGADO EMP_GERENTE
WHERE EMP_OPERACAO.GERENTE = EMP_GERENTE.NUMEMP(+)

9.1. Exercícios

1) Crie uma consulta para a exibir o nome, o número e o nome do departamento de todos os
empregados.

2) Crie uma lista de todos os cargos existentes no departamento 5. Inclua a localização do

departamento 5 na lista.

3) Crie uma consulta para exibir o nome do empregado, o nome do departamento e a localização
de todos os empregados que recebem comissão.

4) Liste o nome do empregado e o nome do departamento para todos os empregados que possuem
“A” em seus nomes. Salve esta consulta na raíz da unidade C: com o nome emp_A.sql, e em
seguida execute a consulta.

5) Crie uma consulta para listar o nome, o cargo, o número e o nome do departamento para todos
os empregados que trabalham em Belo Horizonte.

6) Liste o nome e o número do empregado junto com o nome e o número do gerente. Dê apelidos
para as respectivas colunas.

7) Crie uma consulta que exibirá o nome do empregado, o número do departamento e todos os
empregados que trabalham no mesmo departamento de um determinado empregado. Coloque o
apelido apropriado para cada coluna.

8) Baseando-se na estrutura da tabela FAIXASALARIAL, crie uma consulta que liste o nome, o
cargo, o nome do departamento, o salário e a classificação de todos os empregados.
 45

 Agregação de dados usando funções

As funções de grupo operam em conjuntos de linhas para fornecer um resultado agrupado. Por
exemplo, supondo que seja necessário agrupar o salário de todos os empregados através da soma.
De modo diferente das funções de uma única linha, as funções de grupo operam em conjuntos
de linhas para fornecer um resultado por grupo. Esses conjuntos podem ser a tabela inteira ou a
tabela particionada em grupos. Abaixo seguem os tipos de funções de grupo usadas pelo Oracle11g,
onde cada uma dessas funções aceita um argumento.

Função
AVG (expressão)
COUNT (expressão)
MAX (expressão)
MIN (expressão)
SUM (expressão)
Descrição
Valor médio ignorando valores nulos.
Número de linhas, onde a expressão avalia
para um valor diferente de nulo, ou seja,
serve para contar as linhas selecionadas
usando *, inclusive linhas duplicadas e com
nulos.
Valor máximo ignorando valores nulos.
Valor mínimo ignorando valores nulos.
Soma dos valores ignorando nulos.

As regras para o uso das funções de grupo são:

O uso da palavra-chave DISTINCT faz com que a função considere somente valores não
duplicados.

 Ostipos de dados para os argumentos podem ser CHAR, VARCHAR2, NUMBER ou

DATE.

 Todas as funções de grupo, exceto a função COUNT(*), ignoram valores nulos. Para
substituir um valor por valores nulos, use então a função NVL.

10.1. As funções de Grupo SUM, AVG, M AX e M IN

As funções de grupo SUM, AVG, MAX e MIN, são usadas com colunas que armazenam
dados numéricos. O exemplo abaixo lista maior salário, os menor, a média e a soma dos salários
mensais de todos os vendedores.

SELECT MAX(SALARIO)
, MIN(SALARIO)
, AVG(SALARIO)
, SUM(SALARIO)
FROM EMPREGADO;

Um outro exemplo do uso das funções de agregação é visto abaixo, com o uso da expressão
do tipo VARCHAR2.

SELECT MAX(NOME)
, MIN(NOME)
FROM EMPREGADO;
 46
10.2. A função COUNT
A função COUNT, como foi visto anteriormente, serve para retornar o número de linhas em
um a tabela. Temos duas maneiras para usar a função COUNT: COUNT(*) ou COUNT(expressão).
O COUNT (*) retorna o número de linhas em uma tabela, inclusive as linhas duplicadas e
linhas contendo valores nulos em qualquer umas das colunas. Entretanto, o uso do
COUNT(expressão) retorna o número de linhas não nulas na coluna identificada pelo parâmetro de
expressão.
No exemplo abaixo, é mostrado o retorno do número de empregados do departamento 4.

SELECT COUNT(*) FROM EMPREGADO WHERE NUMDEPT = 4;

Um outro exemplo importante para o uso da função COUNT, é visto abaixo, onde a coluna de
comissão é especificada como parâmetro. Neste caso, só será retornadas a quantidade de linhas que
tiverem valore de comissão.

SELECT COUNT(COMISSAO) FROM EMPREGADO;

NOTA
Caso seja necessário usar a palavra-chave DISTINCT para não contar linha duplicadas, a seguinte
instrução SELECT poderia ser criada: SELECT COUNT( DISTINCT (NUMDEPT)) FROM EMPREGADO.

NOTA
Uma outra forma de se utilizar as funções de grupo, é construir a instrução SELECT com a função NVL.
Neste caso a função NVL força as funções de grupo a incluírem valores nulos. Como por exemplo:
SELECT AVG(NVL(COMISSAO, 0)) FROM EMPREGADO.

10.3. Grupos de Dados

Usa-se a cláusula GROUP BY para dividir as linhas de uma tabela em grupos. Em seguida,
podemos usar as funções de grupo para retornar informações sumarizadas para cada grupo. A
sintaxe do GROUP BY é:

... GROUP BY expressão. Onde, a expressão especifica as colunas cujos valores

determinam a base para o agrupamento de linhas.

10.4. Funções para agurpamento de dados

Se uma função de grupo for incluída em uma cláusula SELECT, não será possível selecionar
resultados individuais, a me n o s q u e a coluna individual apareça na cláusula GROUP BY. Se
não for incluída a lista de colunas, uma mensagem de erro será exibida.
Ao usar uma cláusula WHERE, pode-se excluir linhas com antecedência antes de dividi-las
em grupos. Além disso, não é possível usar o apelido de coluna na cláusula GROUP BY.
Por padrão, as linhas são classificadas por ordem crescente das colunas incluídas na lista
GROUP BY. Esta situação pode ser contornada usando a cláusula ORDER BY.
O exemplo abaixo lista o número do departamento e o salário médio para cada departamento.
A instrução SELECT, que contém uma cláusula GROUP BY, é desenvolvida da seguinte forma:

SELECT NUMDEPT, AVG(SALARIO) FROM EMPREGADO GROUP BY NUMDEPT;

O outro exemplo acrescenta a cláusula ORDER BY para classificar por média salarial.

SELECT NUMDEPT, AVG(SALARIO) FROM EMPREGADO GROUP BY NUMDEPT ORDER

BY AVG(SALARIO);
 47
Os itens a seguir definem melhor a sintaxe para o uso das funções de agrupamento:

 A cláusulaSELECT especifica as colunas a serem recuperadas:

- A coluna de números de departamento na tabela EMPREGADO;
- A média de todos os salários no grupo que você especificou na cláusula GROUP BY;

A cláusula FROM especifica as tabelas que o banco de dados deve acessar: a tabela
EMPREGADO.

A cláusula WHERE especifica as linhas a serem recuperadas. Já que não há uma cláusula
WHERE, todas as linhas são recuperadas por padrão.

A cláusula GROUP BY especifica como as linhas devem ser agrupadas. As linhas são
agrupadas pelo número do departamento, de forma que a função AVG que esteja sendo
aplicada à coluna de salários calcule o salário médio para cada departamento.

É possível retornar resultados sumarizados para grupos e subgrupos listando mais de uma
coluna GROUP BY. Podemos determinar a ordem de classificação padrão dos resultados pela
ordem das colunas na cláusula GROUP BY. A instrução SELECT no exemplo a seguir contém
uma cláusula GROUP BY, é avaliada da seguinte forma:

SELECT NUMDEPT, CARGO, SUM(SALARIO) FROM EMPREGADO GROUP BY

NUMDEPT, CARGO;

Onde:

 A cláusula SELECT especifica a coluna a ser recuperada:

- O número do departamento na tabela EMPREGADO;

- O cargo na tabela EMPREGADO;
- A soma de todos os salários no grupo que foi especificado na cláusula GROUP BY;

 A cláusula FROM especifica as tabelas que o banco de dados deve acessar a tabela
EMPREGADO.

 A cláusula GROUP BY especifica como você deve agrupar as linhas:

- Primeiro, as linhas são agrupadas pelo número do departamento

- Em seguida, dentro dos grupos de números de departamentos, as linhas são agrupadas
pelo cargo.

Dessa forma, a função SUM é aplicada à coluna de salários para todos os cargos dentro de
cada grupo de números de departamentos.

10.5. Erros que ocorrem usando as funções para agrupamento de

dados
Ao usarmos individualmente colunas de dados e funções de grupo na mesma instrução
SELECT, devemos incluir uma cláusula GROUP BY que especificque as colunas de dados
individuais. O exemplo abaixo, mostra uma instrução SELECT que provocará um erro de coluna
ausente na cláusula GROUP BY ou simplesmente que a cláusula é inexistente.
 48

SELECT NUMDEPT, COUNT(CARGO) FROM EMPREGADO;

Assim como na situação acima, caso se deseja restringir grupos de dados em uma instrução
SELECT usando a cláusula WHERE, o Oracle11g irá recusar a execução da consulta, retornando
um erro de que não é possível usar a cláusula WHERE para restringir grupos. O exemplo abaixo,
mostra uma instrução SELECT que provocará um erro mostrando esta situação:

SELECT NUMDEPT, COUNT(CARGO) FROM EMPREGADO WHERE COUNT(CARGO)>=1

GROUP BY NUMDEPT;

Para a restrição de grupos é usada a cláusula HAVING, especificando quais grupos serão
listados. Um exemplo do uso da cláusula HAVING é visto abaixo:

SELECT NUMDEPT, SUM(SALARIO) FROM EMPREGADO GROUP BY NUMDEPT

HAVING SUM(SALARIO) >= 8200 ORDER BY NUMDEPT ;

10.6. Exercícios
1. Crie uma consulta para a exibir os salários maior, menor e a soma de todos os salários de todos
os empregados. Dê apelidos apropriados para as colunas. Além disso, arredonde os resultados.
Salve a consulta como sal_agp.sql.

2. Modifique a consulta sal_agp.sql para exibir o salário maior, médio e a soma de todos os
salários para cada tipo de cargo. Salve a consulta como sal_tipo.sql. Execute a consulta.

3. Crie uma consulta para exibir o número de pessoas por localização de departamento.

4. Crie uma consulta para deteminar o número de gerentes existentes por departamento.

5. Crie uma consulta para exibir a diferença entre os maiores e menores salários.

6. Liste o número do empregado que é gerente e o respectivo salário com o menor salário de
empregado sob sua gerência. Exclua todos os grupos em que o menor salário seja menor que
R$ 1.300. Classifique em ordem descrescente de número de empregado.
 49

 Criação de subconsultas

Neste capítulo serão vistos alguns recursos avançados da instrução SELECT, onde será
possível a criação de subconsultas a partir da cláusula WHERE de outra instrução SQL, a fim de
obter valores baseados em um valor condicional. Um exemplo do uso de subconsulta seria para
descobrir quem recebe tem uma comissão maior que a comissão do vendedor “Marcelo”. Para
resolver este tipo de consulta, é necessário a construção de duas consultas: Uma consulta para
descobrir quanto o “Marcelo” recebe de comissão, e a outra para descobrir quem recebe uma
comissão maior que a do “Marcelo”.
Pode-se resolver essa consulta combinando duas instrução SELECT. Isto é feito colocando
uma consulta dentro da outra. A consulta interna ou a subconsulta retorna um valor que é usado
pela consulta externa ou consulta principal.
Usar uma subsconsulta equivale a executar duas seqüências de consultas, tendo o resultado da
primeira (interna) como valor de pesquisa na segunda consulta. A sintaxe do uso de subconsultas é
mostrada abaixo:

SELECT coluna(s) FROM tabela(s) WHERE expressão_comparação

(SELECT coluna FROM tabela);

Uma subconsulta é uma instrução SELECT que é incorporada em uma cláusula de outra
instrução SELECT. Pode-se desenvolver instruções sofisticadas a partir de instruções simples
usando subconsultas.

NOTA
As subconsultas são muito úteis quando é necessário selecionar linhas de uma tabela com uma condição
que dependa dos dados na própria tabela.

A subconsulta pode ser elaborada de forma semelhante a qualquer instrução SELECT, onde o
desenvolvedor pode usar várias cláusulas, como por exemplo, WHERE, HAVING e FROM.
Através da sintaxe vista anteriormente, o operador da expressão pode ser >, = ou IN. Os
operadores de comparação estão divididos em duas classes distintas: os operadores de uma única
linha (>, =, >=, <, <=, <>) e operadores de várias linhas (IN, ANY, ALL). O exemplo a seguir
mostra o uso de subconsulta:

SELECT NOME
FROM EMPREGADO
WHERE COMISSAO >
(SELECT COMISSAO
FROM EMPREGADO
WHERE NUMEMP = 15);

O exemplo mostra a lista de nomes de empregados que tem comissão maior que a do
empregado cujo número de cadastro é 15.
É importante destacar algumas regras para o uso de subconsultas. Vejamos algumas:

 Uma subconsulta sempre deve estar entre parênteses.

 Uma subconsulta deve aparecer ao lado direito do operador de comparação;

 As subconsultas não podem conter clásusula ORDER BY. Só é possível haver uma cláusula
 50
ORDER BY para uma instrução SELECT e, se estiver especificado, esta cláusula deve ser a última
cláusula na instrução SELECT principal.

 As duas classes de operadores podem ser usadas;

Existem três tipos de subconsultas: Subconsultas de uma única linha, Subconsultas de várias
linhas e Subconsulta de várias colunas. Os próximos itens deste capítulo mostram esses tipos
exemplificando-os.

11.1. Construindo Subconsultas de um única linha

Esse tipo de consulta usa os operadores de uma única linha. Como exemplo, podemos listar
todos os empregados que tenham o mesmo cargo que o empregado 10.

SELECT EMP.NOME
, DEPT.NOMEDEPT
FROM EMPREGADO EMP,
DEPARTAMENTO DEPT
WHERE EMP.NUMDEPT = DEPT.NUMDEPT
AND EMP.CARGO =
(SELECT CARGO
FROM EMPREGADO
WHERE NUMEMP = 10);

O exemplo abaixo é a construção da instrução SELECT através de subconsultas para listar os

empregados cujo o cargo é o mesmo que o cargo do empregado 10 e cujo salário é maior que o do
empregado cujo o número de cadastro é igual a 12.

SELECT EMP.NOME
, DEPT.NOMEDEPT
FROM EMPREGADO EMP,
DEPARTAMENTO DEPT
WHERE EMP.NUMDEPT = DEPT.NUMDEPT
AND EMP.CARGO =
(SELECT CARGO
FROM EMPREGADO
WHERE NUMEMP = 10)
AND EMP.SALARIO >
(SELECT SALARIO
FROM EMPREGADO
WHERE NUMEMP = 12);

Outra situação da construção de instruções SELECT com o uso de subconsultas, é o uso de

funções de grupo. O exemplo abaixo lista o nome do empregado, o número do departamento e o
salário de todos os empregados, cujo salário seja igual ao menor salário da tabela de empregados.
Neste caso, a função MIN() é a mais apropriada para a execução da consulta.

SELECT NOME, NUMDEPT, SALARIO

FROM EMPREGADO
WHERE SALARIO =
(SELECT MIN(SALARIO)
FROM
 51
EMPREGADO);

Além do uso de funções de grupo na construção de instruções SELECT com subconsultas, é

possível também a utilização da cláusula HAVING com subconsutas. O exemplo a seguir lista o
cargo e o menor salário médio.

SELECT CARGO
, AVG(SALARIO)
FROM EMPREGADO
GROUP BY CARGO
HAVING AVG(SALARIO) = (SELECT MIN(AVG(SALARIO))
FROM EMPREGADO
GROUP BY CARGO);

11.2. Construindo Subconsultas de várias linhas

É possível usar um operador de várias linha para executar este tipo de subconsulta, esperando
um ou mais valores. O exemplo abaixo localiza o menor salário de todos os departamentos exibindo
o nome, o salário e o código do departamento para cada empregado.

SELECT NOME
, SALARIO
, NUMDEPT
FROM EMPREGADO
WHERE SALARIO IN (
SELECT MIN(SALARIO)
FROM EMPREGADO
GROUP BY NUMDEPT
);

O operador ANY serve como operador de comparação, e compara um valor a cada valor
retornada por uma subconsulta. O exemplo abaixo lista os empregados cujo salário é menor que o
de qualquer vendedor, que não são vendedores.

SELECT NUMEMP
, NOME
, CARGO
FROM EMPREGADO
WHERE SALARIO < ANY
(SELECT SALARIO
FROM EMPREGADO
WHERE CARGO = ‘VENDEDOR’)
AND CARGO <> ‘VENDEDOR’;

NOTA
O uso do ANY: < ANY  Significa menos do que o máximo . > ANY  Significa mais do que o
mínimo. = ANY  Equivale ao IN.

O operador ALL compara um valor a todo valor retornado por uma subconsulta. O exemplo
abaixo lista os empregados cujo salário seja maior que os salários médios de todos os
departamentos, exibindo apenas o nome e o cargo do empregado.
 52

SELECT NOME
, CARGO
FROM EMPREGADO
WHERE SALARIO > ALL
(SELECT AVG(SALARIO)
FROM EMPREGADO
GROUP BY NUMDEPT)

NOTA
O operador NOT não pode ser usado com os operadores de várias linhas (IN, ANY e ALL) .

11.3. Exercícios
1. Crie uma consulta para o número de cadastro do empregado e a data de nascimento de todos os
empregados do mesmo departamento de Sebastião. Não considere o Sebastião.

2. Elabore uma consulta para listar o número e o nome de todos os empregados que recebam mais
que o salário médio e ordene os resultados por ordem descrecente de nome do empregado.

3. Crie uma consulta que liste o nome de todos os empregados que trabalhem em um departamento
com qualquer localização de departamento cujo nome da localização contenha a letra L. Salve o
arquivo com o nome local_L.sql.

4. Crie uma consulta que exiba o nome do empregado, o número do departamento e o cargo de
todos os empregados cuja localização do departamento seja Rio de Janeiro.

5. Crie uma consulta que liste o número de cadastro e o salário dos empregados que tenham como
gerente o empregado Pedro Paulo.
 53

 DML (Data Manipulation Language)

Segundo o manual da Oracle [ORA 07], o DML (Data Manipulation Language) é uma parte
essencial do SQL. Quando for necessário adicionar, atualizar ou apagar dados no banco de dados,
deve-se executar uma instrução DML.
Um conjunto de instruções DML que formam uma unidade lógica de trabalho é chamada de
transação. Como exemplo, podemos considerar um banco de dados bancário. Quando o cliente de
um banco transfere dinheiro de uma conta de poupança para uma conta corrente, a transação
consiste em três operações separadas: diminuir a conta poupança, aumentar a conta corrente e
registrar a transação no lançamento da transação. O servidor Oracle deve garantir que todas as
três instruções SQL sejam executadas para manter as contas com o saldo apropriado. Quando algo
impedir que uma das instruções na transação seja executada, as outras instruções da transação
deverão ser desfeitas.

12.1. Inserindo registros com a instrução INSERT

Pode-se inserir linhas de registros em uma tabela usando a instrução INSERT. A sintaxe é a
seguinte:

INSERT INTO TABELA (COLUNA1, COLINA2, ...) VALUES (VALOR_COLUNA_1,

VALOR_COLUNA_2...);

Para inserir uma nova linha que contenha valores para cada coluna, a lista de colunas não é
requerida na cláusula INSERT. Entretanto, se não for usada a lista de colunas, os valores deverão
ser listados de acordo com a ordem padrão das colunas na tabela.

NOTA
Caso seja necessário saber as colunas da tabela que receberá as linhas de registros, devemos usar o
comando DESC[RIBE] . Por exemplo: DESC DEPARTAMENTO;

Abaixo segue um exemplo do uso da instrução INSERT:

INSERT INTO EMPREGADO (

NUMEMP
, NUMDEPT
, NOME
, CARGO
, DTNASC
, SALARIO
, GERENTE
, COMISSAO
) VALUES (
1
, 1
, 'MARIA'
, 'PRESIDENTE'
, TO_DATE('17/11/1975','DD/MM/YYYY')
, 5000
, NULL
, NULL
);

Observe na instrução acima que foram inseridos valores nulos. Mas é bom destacar que
 54
devem ser analisadas as restrições na tabela, como por exemplo, uma coluna não poder aceitar nulo.
Neste caso o Oracle iria rejeitar a inserção do registro.
Outra observação a ser feita é a utilização da função TO_DATE. A data informada no
exemplo está diferente do formato de data padrão, portanto foi necessário fazer a conversão do
valor informado.

12.2. Inserindo linhas de registros a partir de outra tabela

Usa-se a instrução INSERT para adicionar linhas a uma tabela onde os valores são derivados
de tabelas existentes, e neste caso no lugar da cláusula VALUES é usada uma subconsulta. A
sintaxe abaixo representa esta operação:

INSERT INTO TABELA (COLUNA1, COLUNA2, ...) (SUBCONSULTA)

O exemplo a seguir mostra o uso da instrução INSERT com subconsulta:

INSERT INTO GERENTE (

CODGER
, NOMEGER
, SALARIOGER
) (
SELECT NUMEMP
, NOME
, SALARIO
FROM EMPREGADO
WHERE CARGO = ‘GERENTE’
);

12.3. M odificando linhas usando a instrução UPDATE

A instrução UPDATE serve para atualizar um ou mais linhas de registros de uma tabela. A
sintaxe abaixo mostra como se deve construir uma instrução UPDATE.

UPDATE TABELA SET COLUNA1 = VALOR1, COLUNA2 = VALOR2, ... [WHERE

CONDICAO]

A cláusula WHERE na instrução UPDATE é opcional, caso seja necessário restringir as linhas
a serem atualizadas. O dois exemplos abaixo mostram esta situação:

UPDATE EMPREGADO
SET NUMDEPT = 3
WHERE NUMEMP = 12;

UPDATE EMPREGADO
SET COMISSAO = 0;

O primeiro exemplo atualiza para 3 o número do departamento do empregado de número de

registro igual a 12. O segundo exemplo atualiza para 0 as comissões de todos os empregados.
Além das situações acima, o Oracle também permite a atualização de registro com uma
subconsulta de várias colunas. Veja o exemplo abaixo:
 55
UPDATE EMPREGADO SET (CARGO, NUMDEPT) =
(SELECT CARGO, NUMDEPT
FROM EMPREGADO
WHERE NUMEMP = 3)
WHERE NUMEMP = 17;

12.4. Apagando linhas usando a instrução DELETE

A instrução DELETE serve para apagar um ou mais linhas de registros de uma tabela. A
sintaxe a seguir mostra o uso da instrução DELETE:

DELETE FROM TABELA [WHERE CONDICAO]

Semelhante à instrução INSERT, a cláusula WHERE é opcional, caso seja necessário

restringir as linhas a serem apagadas. Abaixo segue dois exemplos do uso da instrução DELETE.

DELETE FROM EMPREGADO WHERE NUMEMP=11;

DELETE FROM DEPARTAMENTO;

O primeiro exemplo apaga o empregado, cujo número de empregado é igual a 11. O segundo
exemplo, permite apagar todos os registros da tabela departamento.
Além das situações acima, o Oracle também permite a deleção de registros baseada em outra
tabela. Veja o exemplo abaixo:

DELETE FROM EMPREGADO

WHERE NUMDEPT = (
SELECT NUMDEPT
FROM DEPARTAMENTO
WHERE LOCALIZACAO = ‘SAO PAULO’);

12.5. Controle de transações

De acordo com o manual da Oracle [ORA 07], o servidor de banco de dados garante
consistência dos dados baseando-se em transações. As transações lhe dão mais flexibilidade e
controle ao alterar dados e garantem a consistência de dados no caso de falha do usuário ou do
sistema.
As transações consistem de instruções DML que façam uma alteração consistente nos dados.
Por exemplo, uma transferência de fundos entre duas contas deve incluir o débito em uma conta e o
crédito em outra com mesma quantia. Ambas as ações devem falhar ou ter êxito juntas. O crédito
não deve ser processado sem o débito.
Uma transação inicia quando a primeira instrução SQL executável for encontrada, e termina
quando ocorrer uma das seguinte situações:

 Uma instrução COMMIT ou ROLLBACK for emitida. Uma instrução DDL, como CREATE,
for emitida. Uma instrução DCL for emitida;

 usuário sair da Execução de Linha de Comando (SQL PLUS);

 Houver urna falha no computador ou o sistema cair;

 Depois que uma transação termina, a próxima instrução SQL executável automaticamente inicia
apróxima transação.
 56
Uma instrução DDL ou DCL(Data Control Language) é automaticamente processada e,
portanto, finaliza implicitamente uma transação.
As instruções COMMIT e ROLLBACK tem várias vantagens. Pode-se destacar a garantia
de consistência de dados, a visualização das alterações nos dados, antes de fazer alterações
permanentemente, e o agrupamento de operações relacionandas logicamente.

NOTA
DCL permite a implementação da segurança interna do Banco de dados. Seus comandos principais são
GRANT e REVOKE.

12.6. Exercícios
 Execute o script tabela_exer.sql existente na unidade C: . Este processo irá criar a tabela
PRODUTO usada para execução dos exercícios deste capítulo.

 Liste a estrutura da tabela PRODUTO para que sejam identificadas as colunas.

 Adicione as primeiras linhas de dados na tabela PRODUTO a partir dos dados do exemplo a
seguir.

CODPRODUTO NOME_PRODUTO VALOR_UNITARIO DATA_CADASTRO

1 ARROZ 10,50 01/01/1997
2 FEIJAO 3,40 21/05/1998
3 MACARRAO 4,78 23/09/2000
4 FARINHA 2,10 08/08/1998

 Verifique a inserção das linhas de registro. Por exemplo, usando a instrução SELECT.

 Altere o nome do produto 2 para SABAO EM PO.

 Altere a data para 15/09/2001 de todos os produtos que tenham valor unitário maior ou igual a
R$ 4,50.

 Verifique as alterações na tabelas.

 Apague o produto com o nome macarrão da tabela.

 Verifique as mudanças na tabela.

 Execute o COMMIT para todas as mudanças pendentes.

 Esvazie a tabela inteira.

 Verifique se ela está vazia.

 Descarte a operação de deleção da tabela.

 Verifique se os dados estão na tabela.

 Esvazie novamente a tabela.

 Torne a deleção permanente.

 57

 Criação e Gerenciamento de Tabelas

Um banco de dados Oracle pode conter várias estruturas dados, onde cada estrutura deve ser
descrita no projeto do banco de dados para que possa ser criada durante o estágio de
desenvolvimento do banco de dados. Estas estruturas podem ser tabelas, visões, estruturas de
seqüência, índices ou sinônimos.
As tabelas podem ser criadas a qualquer momento, até mesmo quando os usuários estiverem
usando o banco de dados, e, além disso, a estrutura da tabela pode ser modificada on-line.
Existem convenções para criar tabelas, as quais devem começar com uma letra, pode ter 1 a
30 caracteres contendo somente A-Z, a-z, 0-9, _, $ e #. Também, não deve ser uma palavra
reservada pelo Oracle.
Para criar uma tabela no Oracle, o usuário deve ter privilégio de CREATE TABLE, ou seja,
ter o direito de criar tabelas com a instrução mencionada. A sintaxe da instrução CREATE TABLE
tem que ser especificada com o nome da tabela, o nome da coluna, o tipos de dados e o tamanho da
coluna. Abaixo segue a sintaxe:

CREATE TABLE TABELA(COLUNA1 TIPO DE DADOS [DEFAULT EXPRESSÃO],

COLUNA2 TIPO DE DADOS [DEFAULT EXPRESSÃO], ...);

Onde, DEFAULT EXPRESSÃO, especifica um valor padrão se um valor estiver omitido na

instrução INSERT. Abaixo segue um exemplo do uso da instrução CREATE TABLE.

CREATE TABLE PRODUTO

(
CODPRODUTO NUMBER(4) ,
NOME_PRODUTO VARCHAR2(50) ,
VALOR_UNITARIO NUMBER(10,2) ,
DATA_CADASTRO DATE DEFAULT SYSDATE
);

Ao criar objetos no servidor Oracle é possível consultar no dicionário de dados as tabelas,

visões entre outros objetos. Abaixo segue alguns exemplos destas consultas.

 Descreve as tabelas que o usuário tem acesso.

SELECT * FROM USER_TABLES;

 Exibe os tipos de objetos distintos os quais o usuário tem acesso.

SELECT OBJECT_TYPE FROM USER_OBJECTS;

 Exibe as tabelas, visões, sinônimos e estruturas de seqüências que o usuário tem acesso.

SELECT * FROM USER_CATALOG;

Vários são os tipos de dados usados pelo Oracle criar as colunas de uma tabela. Abaixo
seguem os principais tipos:
 58

Tipos de Dados Descrição

VARCHAR2(tamanho) Dados de caractere de
comprimento variável.
CHAR(tamanho) Dados de caractere de
comprimento fixo.
NUMBER(p, s) Dados numéricos de comprimento
variável.
DATE Valores de data e hora.
LONG Dados de caractere de
comprimento variável até 2
gigabytes.
CLOB Dados de caractere de
comprimento variável até 4
gigabytes.
BLOB Dados binários de até 4
gigabytes.

13.1. Instruções de modificação e deleção de tabelas

Com a instrução ALTER TABLE é possível alterar uma tabela adicionando, modificando e
definido valores default ou tipos de dados para as colunas.
Para adicionar uma coluna podemos usar a cláusula ADD. O exemplo abaixo mostra o uso
desta cláusula:

ALTER TABLE DEPARTAMENTO ADD(DATA_CRIACAO_REG DATE);

Para modificar uma tabela podemos usar a cláusula MODIFY:

ALTER TABLE DEPARTAMENTO MODIFY(LOCALIZACAO VARCHAR2(80));

Para apagar uma coluna podemos usar a cláusula DROP:

ALTER TABLE DEPARTAMENTO DROP COLUMN DATA_CRIACAO_REG;

Além de todos os comandos usados para alteração de uma tabela, também é possível apagá-la,
onde todos os seus dados e estrutura são excluídos, e também todos os índices serão eliminados.
Através da instrução DROP TABLE, mostrada no exemplo abaixo, é possível apagar uma tabela.

DROP TABLE PRODUTO;

Após a criação de uma tabela é possível a alteração do nome da mesma usando a instrução
RENAME:

RENAME DEPARTAMENTO TO DEPTM;

 59
13.2. Exercícios
 Crie a tabela itens de produto com o nome ITENS_PRODUTO de acordo com a tabela de
exemplo a seguir, em seguida confirme se a tabela foi criada.

Nome da COD_REG_ITEM DESCRICAO_MOTIVO_DESCONTO VALOR_VENDA_ITEM

Coluna
Tipo de NUMBER VARCHAR2 NUMBER
Dado
Tamanho 4 100 10,2

 Modifique a tabela ITENS_PRODUTO para aceitar campo do tipo longo no campo da descrição
do motivo do desconto.

 Verifique se a tabela ITENS_PRODUTO existe no dicionário de dados.

 Crie uma tabela chamada ITENS_2 de acordo com a estrutura da tabela ITENS_PRODUTO.

 Apague a tabela ITENS_PRODUTO.

 Renomeie a tabela ITENS_2 para ITENS_PRODUTO.

 Elimine a coluna do valor de venda do item, e confirme a alteração na tabela através da listagem
da estrutura.

 Altere o tipo de dado da coluna COD_REG_ITEM, para o tipo NUMBER com o tamanho 10.
 60

 Restrições em tabelas

As restrições são usadas para impor regras no nível de tabela, evitando, por exemplo, que uma
tabela seja apagada se houver dependências. Os seguintes tipos de restrição são válidos no Oracle:

 NOT NULL;

 PRIMARY KEY;

 FOREIGN KEY.

A restrição NOT NULL, especifica que a coluna não pode conter um valor nulo. Já a restrição
PRIMARY KEY identifica exclusivamente cada linha da tabela. Por último, a restrição FOREIGN
KEY impõe um relacionamento de chave estrangeira entre a coluna da tabela criada e a coluna da
tabela referencia. Abaixo segue um exemplo que mostra o uso de restrições do Oracle.

CREATE TABLE EMPREGADO(

NUMEMP NUMBER(5) NOT NULL,
NUMDEPT NUMBER(4) NOT NULL,
NOME VARCHAR2(50) NOT NULL,
CARGO VARCHAR2(30) NOT NULL,
DTNASC DATE NOT NULL,
SALARIO NUMBER(7,2) NOT NULL,
GERENTE NUMBER(5),
COMISSAO NUMBER(7,2),
CONSTRAINT PKEMPREGADONUMEMP PRIMARY KEY (NUMEMP),
CONSTRAINT FKEMPREGADONUMDEPT FOREIGN KEY (NUMDEPT) REFERENCES
DEPARTAMENTO(NUMDEPT));

A restrição NOT NULL é especificada em nível de coluna e não de tabela. Observe que a
restrição NOT NULL é usada após o tipo de dado.
A restrição PRIMARY KEY cria uma chave primária para a tabela. Somente uma chave
primária pode ser criada para cada tabela. Além disso, a PRIMARY KEY é uma coluna ou conjunto
de colunas que identifica exclusivamente cada linha em uma tabela. Essa restrição impõe a
exclusividade da coluna ou combinação de colunas, assegurando que nenhuma coluna que seja parte
da chave primária possa conter um valor nulo. Observe no exemplo anterior que a restrição
PRIMARY KEY está sendo criada com o uso da cláusula CONSTRAINT (restrição), em seguida
vem o nome da chave, por exemplo, PKEMPREGADONUMEMP, e o nome da coluna entre parênteses
na restrição PRIMARY KEY.
A restrição FOREIGN KEY, permite criar uma restrição de integridade referencial, a qual
designa uma coluna ou combinação de colunas como chave estrangeira e estabelece um
relacionamento entre a chave primária ou uma chave exclusiva na mesma tabela ou uma tabela
diferente. No exemplo anterior novamente é usada cláusula CONSTRAINT (restrição) para o uso
da restrição FOREIGN KEY, onde outra cláusula é colocada (REFERENCES) para referenciar a
outra tabela que faz parte do relacionamento. No exemplo, a tabela que se relaciona com
EMPREGADO é a tabela DEPARTAMENTO através do campo NUMDEPT.
 61
14.1. M odificando as restrições de uma tabela
Até o momentofoi visto a criação de restrição na instrução CREATE TABLE. Mas é possível
nós criarmos restrição após a instrução CREATE TABLE. Por meio da instrução ALTER TABLE,
as restrições são adicionadas ou removidas.
Abaixo segue dois exemplos mostrando estas situações:
 Adiciona uma restrição FOREIGN KEY à tabela EMPREGADO, indicando que um gerente
deve existir como um empregado válido na tabela EMPREGADO.

ALTER TABLE EMPREGADO

ADD CONSTRAINT FKEMPREGADOGERENTE
FOREIGN KEY(GERENTE) REFERENCES EMPREGADO(NUMEMP);

 Apaga a restrição de chave estrangeira da tabela EMPREGADO.

ALTER TABLE EMPREGADO

DROP CONSTRAINT FKEMPREGADOGERENTE;

14.2. Exercícios
1. Crie a tabela itens de produto com o nome ITENS_PRODUTO de acordo com o exemplo a
seguir, usando a restrição NOT NULL de forma adequada, em seguida confirme se a tabela foi
criada.

Nome da COD_REG_ITEM DESCRICAO_MOTIVO_DESCONTO VALOR_VENDA_ITEM

Coluna
Tipo de NUMBER VARCHAR2 NUMBER
Dado
Tamanho 4 100 10,2
Nulo? NOT NULL NOT NULL

2. Adicione uma restrição PRIMARY KEY à tabela ITENS_PRODUTO, usando a coluna

COD_REG_ITEM. A restrição deve ser nomeada quando for criada.

3. Crie a tabela produto com o nome PRODUTO de acordo com a tabela de exemplo a seguir,
usando a restrição NOT NULL e a criação do valor padrão de forma adequada, em seguida
confirme se a tabela foi criada.

Nome da COD_PRODUTO NOME DATA_CADASTRO

Coluna
Tipo de NUMBER VARCHAR2 DATE
Dado
Tamanho 4 50
Nulo? NOT NULL NOT NULL NOT NULL
Valor SYSDATE
Padrão

4. Altere a estrutura da tabela ITENS_PRODUTO, adicionando a coluna COD_PRODUTO com

as mesmas características da coluna código do produto da tabela PRODUTO.

5. Adicione uma restrição PRIMARY KEY à tabela PRODUTO, usando a coluna

COD_PRODUTO. A restrição deve ser nomeada quando for criada.
 62
6. Adicione uma referência de chave estrangeira na tabela ITENS_PRPDUTO, que irá assegurar
que a tabela de itens de produto não terá produtos inexistentes.

7. Confirme se as restrições foram adicionadas, consultando a tabela de objetos

USER_CONSTRAINTS. Observe os tipos e nomes das restrições.
 63

 Criação de Views

É possível criar visões (views) para apresentar combinações ou subconjuntos lógicos de
dados, criando as views a partir de tabelas. Uma view é uma tabela lógica baseada em uma tabela
ou outra view. Uma view não contém dados próprios, mas é como uma “janela” através da qual os
dados das tabelas podem ser vistos ou alterados. As tabelas nas quais uma view é baseada são
chamadas de tabelas-base. O armazenamento de uma view é feito através de uma instrução
SELECT.
Vários são os motivos para se criar views, entre eles podemos citar a restrição de acesso a
dados ou acesso direto à estrutura das tabelas, serve para facilitar as consultas complexas, permite
independência dos dados, além disso, as views podem apresentar diferentes visões dos mesmos
dados.
Podemos criar uma view incorporando uma subconsulta na instrução CREATE VIEW.
Abaixo segue a sintaxe para a criação de uma view:

CREATE [OR REPLACE] VIEW NOME

AS SUBCONSULTA;

Onde, OR REPLACE é opcional, e recria a view se ela já existir. Abaixo segue um exemplo
de criação de view:

CREATE VIEW VW_EMPREGADO AS

SELECT NUMEMP AS CODIGO_EMP
, NOME AS NOME_EMP
, DTNASC AS DATA_NASCIMENTO
, SALARIO
FROM EMPREGADO;

No exemplo acima é criada uma view simples contendo apenas as colunas da tabela de
empregado. Para confirmar a criação da view, podemos executar o comando DESC[RIBE],
analisando a estrutura criada Logo após podemos usar a instrução SELECT para recuperar dados da
view. A seguir estão relacionados dois exemplos mostrando outras situações de criação de views.

CREATE VIEW VW_EMPREGADO_SALARIO AS

SELECT NUMEMP
, NOME
, SALARIO
FROM EMPREGADO WHERE SALARIO>=2000;

CREATE VIEW VW_EMPREGADO_DEPT_SALARIO AS

SELECT EMP.NOME AS NOME_EMPREGADO
, DEPT.NOMEDEPT NOME_DEPARTAMENTO
, DEPT.LOCALIZACAO
FROM EMPREGADO EMP
, DEPARTAMENTO DEPT
WHERE EMP.NUMDEPT = DEPT.NUMDEPT
AND EMP.SALARIO>=1950;

CREATE VIEW VW_QTDE_EMPREGADO_DEPT AS

SELECT COUNT(NUMEMP) QTDE_EMPREGADO_DEPT
FROM EMPREGADO WHERE NUMDEPT = 3;
 64

O terceiro exemplo listado acima cria uma view com a estrutura mais complexa, onde lista no
campo QTDE_EMPREGADO_DEPT a quantidade de empregados do departamento 3.
Além das operações acima, o manuseio de views precisa de regras, onde só podemos executar
operações DML em views simples. Não podemos remover uma linha se a view contiver funções de
grupo, cláusula GROUP BY ou a palavra-chave DISTINCT.

15.1. Exercícios
 Crie uma view chamada VW_EMPREGADO baseada no nome e número do empregado e
número e número do departamento da tabela de empregados. Coloque nomes de apelidos nas
colunas para nome do empregado.

 Liste o texto e o nome da view a partir do dicionário de dados USER_VIEWS.

 Exiba o conteúdo e a estrutura da view VW_EMPREGADO.

 Usando a view VW_EMPREGADO, elabore uma consulta para exibir todos os nomes dos
empregados e os números de departamento.

 Crie uma view com o nome de VW_DEPARTAMENTO_NUM_DOIS que contenha o número

e o nome do empregado e o número de departamento de todos os empregados que trabalham no
departamento 2.

 Exiba a estrutura e o conteúdo da view VW_DEPARTAMENTO_NUM_DOIS.

 65

 Instruções e comandos avançados para Administração do

Oracle 11g XE
O Oracle XE possui uma organização física baseada em arquivos de configuração que podem
apoiar o Administrador de Banco de Dados (ABD ou DBA Database Administrador) na
manutenção preventiva ou corretiva do SGBD e das bases de dados.
Algumas visões, ou views, são usadas para listar os arquivos, bem como os parâmetros de
configuração do banco de dados. Abaixo são listadas as principais visões para identificação dos
arquivos que organizam fisicamente o SGBD:

 v$datafile: Lista os arquivos que contém os dados ou metadados que constam tabelas, índices,
áreas temporárias, entre outros;
 v$controlfile: São os arquivos de controle responsáveis pelo sincronismo entre todos os arquivos
do SGBD;
 v$logfile: Lista os arquivos que armazenam o histórico de transações efetuadas.

NOTA
No Oracle XE (eXpress Edition) não é permitido a criação de uma nova instância (ou banco de dados -
Database) além da instância XE, criada quando se instala o SGBD. Desta forma, somente é permit ida a
criação de usuários (Schemas), e logo em seguida as tabelas, índices, etc.

Ao instalar o Oracle XE, são criados usuários que servirão para manutenção de novos objetos
no banco de dados, e também a criação de novos usuários, tablespaces e schemas. Os usuários de
sistema são: SYSTEM, SYS e HR. Abaixo são comentadas as características de cada usuário
padrão:

 SYSTEM: pode executar as tarefas de gerenciamento do banco de dados, mas não pode iniciar e
parar uma instância
 SYS: possui o privilégio de SYSDBA e assim pode executar todas as tarefas administração
 HR (Human Resource): corresponde a uma esquema-padrão que o banco de dados cria para fins
de estudo.

16.1. Iniciando e abrindo o banco de dados por meio de comandos

Para que um banco de dados esteja pronto para ser utilizado, é necessário executar algumas
etapas de inicialização. As três operações abaixo resumem as etapas de inicialização:

 Nomouting: Estado que permite a criação de banco de dados ou recuperação de danos, como por
exemplo, nos arquivos de controle;
 Mounting: Os arquivos de controle são lidos e determina-se a localização de demais arquivos;
 Opening: Os arquivos de dados e logs são abertos.
 66

O DBA pode utilizar algumas ferramentas para desativar o banco de dados e executar
manualmente as etapas citadas anteriormente. Primeiramente, de uma maneira prática, deve-se
utilizar o SQLPlus, e o DBA deve-se conectar como usuário SYS. O exemplo abaixo mostra como
deve ser feita esta conexão:

SQL> CONN SYS/<PASSWORD> AS SYSDBA

NOTA
Somente é possível executar os comandos de inicialização de banco como SYSDBA.

O comando SHUTDOWN
Serve para fechar uma Instância ou Banco de Dados. Exemplo:

SQL> SHUTDOWN

Database closed

Database dismounted

Oracle instance shut down.

O comando STARTUP
Serve para abrir uma instância ou Banco de Dados. Exemplo:

SQL> STARTUP
Oracle instance started.
Total System Global Area 15077376 bytes.
Fixed Size 49152 bytes.
Variable Size 12906496 bytes.
Database Buffers 2048000 bytes.
Redo Buffers 73728 bytes.

Database mouted.
Database opened.

Também é possível iniciar o banco sem passar pela etapa de MOUNTING. Basta digitar o
comando STARTUP NOMOUNT, em seguida aplicar os comandos ALTER DATABASE MOUNT e
ALTER DATABASE OPEN.

NOTA
O comando STARTUP NOMOUNT pode ser usado quando o DBA precisa iniciar o banco de dados mas
mesmo assim necessita efetuar algumas alterações em arquivos físicos de dados ou de controle, para em
seguida montar e abrir o banco de dados.
 67
16.2. Exercícios

1. Liste todos os arquivos de dados existentes no banco.

2. Liste todos os arquivos de controle existentes no banco.

3. Por meio de um utilitário apropriado, feche a instancia do banco de Dados.

4. Inicie o banco de dados sem montá-lo completamente.

5. Monte o banco de dados e depois abre-o.

 68

16.3. Organização Lógica: Tablespaces

Uma tablespace representa uma entidade lógica capaz de reunir dados (de controle,
temporários ou dados propriamente ditos) que guardem semelhanças entre si. É possível criar
tablespaces para tabelas ou índices. Além disso, as tablespaces podem ajudar na organização de
dados com relação ao tamanho, onde tabelas ou índices maiores podem ser organizados em
tablespaces maiores, e vice-versa.
Quando o Oracle XE é instalado, são criadas quatro tablespaces. Elas servem para organizar
logicamente as tabelas e os usuários de sistema. Um banco de dados pode ter uma ou várias
tablespaces, e uma tablespace pode ter um ou vários date files. Além disso, um banco de dados
pode ter vários usuários “donos” de schemas, e um schema pode ter tabelas e índices que estão
organizados pelas tablespaces dentro do banco de dados.
Cada tablespace criada após a instalação tem sua importância para o funcionamento do Oracle
XE. De forma resumida pode-se descrever as seguintes tablespaces:

 SYSTEM : Contém tabelas do dicionários de dados e o segmento de UNDO SYSTEM;

 SYSAUX: Dados dos usuários
 UNDO: Onde ficam os dados e transações antigas
 TEMP: Dados temporários

16.4. Criação de Tablespaces

O comando CREATE TABLESPACE, detalhado abaixo, permite criar as tablespaces no
Oracle XE.

CREATE TABLESPACE nome

DATEFILE ‘caminho_completo_arquivo_1’ SIZE inteiro [K | M]
MAXSIZE inteiro [K | M],
‘caminho_completo_arquivo_2’ SIZE inteiro [K | M]
MAXSIZE inteiro [K | M]
DEFAULT STORAGE (
INITIAL inteiro [K | M]
NEXT inteiro [K | M]
MINEXTENTS inteiro
MAXEXTENTS inteiro
PCTINCREASE inteiro entre 0 e 100)
[ONLINE | OFFLINE]

Exemplo:
CREATE TABLESPACE tbl_teste_2
DATAFILE 'c:\auladba\tbl_teste_1.dbf' SIZE 1024K AUTOEXTEND ON
MAXSIZE 10M
,'c:\auladba\tbl_teste_2.dbf' SIZE 1024K AUTOEXTEND ON
MAXSIZE 10M
DEFAULT STORAGE(
INITIAL 100K
NEXT 10K
MINEXTENTS 1
MAXEXTENTS 255
PCTINCREASE 0)
 69

As palavras-chave e os parâmetros estão detalhados a seguir:

Palavra-chave Descrição
DATEFILE Indica um ou mais arquivos que constituirão a Tablespace. Deve ser
especificado, além do caminho completo, o tamanho (em KB ou MB) e a
possibilidade de reaproveitar um arquivo existente.

Recomenda-se que, somente seja acrescentado um segundo arquivo, quando

o primeiro atingir o tamanho máximo permitido pelo Sistema Operacional.

Dica: o Oracle XE aloca mais espaço do que o especificado, portanto, antes

de criar um DATAFILE, é importante verificar se existe espaço disponível
no disco para uma vez e meia o tamanho do arquivo.
DEFAULT Parâmetro de arqmazenamento:
STORAGE INITIAL: tamanho do primeiro EXTENT alocado (em bytes). Default: 10
Kb.
NEXT: quantos bytes serão alocados no momento da expansão. Não há
garantias de que serão contíguos. Default: 10Kb
MINEXTENTS: quantos EXTENTS deverão ser alocados na criação de mais
um segmento para a Tablespace. Default:1.
MAXEXTENTS: quantidade máxima de EXTENTS alocados por segmento
de Tablespace. Default:10
PCTINCREASE: porcentagem de crescimento aplicada na expansão.
ONLINE Determina se a Tablespace estará disponível imediatamente após a criação
ou não (OFFLINE).
OFFLINE Determina que a Tablespace esteja indisponível após a sua criação,
garantindo que os arquivos estejam disponíveis para manutenção ou algum
procedimento de recuperação caso tenha danos.
AUTOEXTEND Um arquivo pode ser automaticamente expandido por um valor fixo até um
limite ou indefinidamente.

NOTA
Ao criar um usuário, pode-se especificar Tablespaces de dados e/ou temporárias. Isto é altamente
recomendável, pois ajuda bastante quando for necessário exportar uma Tablespace para eliminar
fragmentação ou pode ser usada para exportar objetos. Por exemplo:

CREATE USER NOVO IDENTIFIED SENHA

DEFAULT TABLESPACE USER_DATA
TEMPORARY TABLESPACE TEMPORARY_DATA;

NOTA
O valores dos Parâmetros de Armazenamento (INITIAL, NEXT, etc.) devem ser obtidos após análise dos
scripts de criação das tabelas. A partir dos tamanhos de cada registro e previsão de volume de dados,
pode-se especificar o tamanho máximo que uma tabela com seus índices alcançará. Recomenda-se
superestimar esses valores. Outra dica importante, que os discos que conterão Tablspaces com dados
tenham entre 20 e 25% de espaço livre. O exemplo seguinte mostra a evolução do tamanho de uma tabela
criada com o INITIAL = 100K, NEXT 50K e PCTINCREASE 100.

* Supondo que cada bloco tenha 2.048 bytes

INITIAL 50 102,4 bytes

NEXT 25 51,2 bytes
PCTINCREASE 100
 70
EXTENTS TAMANHO EXPANDE NOVO EM BLOCOS
1 100 0 100 50
2 100 50 150 75
3 150 100 250 125
4 250 200 450 225
5 450 400 850 425
6 850 800 1650 825

Para comprovar a criação de uma tablespace o DBA deve consultar a visão

dba_tablespace. Por exemplo:

SELECT TABLESPACE_NAME FROM DBA_TABLESPACES;

Para comprovar o espaço ocupado, usa-se a visão dba_free_space. Por exemplo:

SELECT * FROM DBA_FREE_SPACE WHERE TABLESPACE_NAME = ‘TABELAS’;

À medida que Segmentos com seus EXTENTS vão sendo criados e apagados, a tendência é
que surjam várias “ilhas” de blocos disponíveis. Quanto mais “ilhas”, maior a fragmentação e pior a
performance.

16.5. Alteração de Tablespaces

O comando ALTER TABLESPACE, detalhado abaixo, permite alterar TableSpaces.

ALTER TABLESPACE nome

ADD DATAFILE ‘caminho_completo_1’ SIZE inteiro [K|M],
‘caminho_completo_2’ SIZE inteiro [K|M]
RENAME DATAFILE ‘ARQUIVO_VELHO’ TO ‘ARQUIVO_NOVO’
COALESCE
DEFAULT STORAGE(
NEXT inteiro [K | M]
MAXEXTENTS inteiro
PCTINCREASE inteiro entre 0 e 100)
ONLINE | OFFLINE

Exemplo:

ALTER TABLESPACE tbl_teste_2

ADD DATAFILE 'c:\auladba\tbl_teste_3.dbf' SIZE 1024K

ALTER TABLESPACE tbl_teste_2

ADD DATAFILE 'c:\auladba\tbl_teste_5.dbf' SIZE 1024K

ALTER TABLESPACE tbl_teste_2 OFFLINE

--Para renomear um DATAFILE, por exemplo, “tbl_teste_3.dbf”.

Antes deve-se copiar o DATAFILE “tbl_teste_5.dbf” para a raiz
da unidade C:\, por exemplo.
ALTER TABLESPACE tbl_teste_2
RENAME DATAFILE 'c:\auladba\tbl_teste_3.dbf' TO
'c:\tbl_teste_5.dbf'
ALTER TABLESPACE tbl_teste_2 ONLINE
ALTER TABLESPACE tbl_teste_2 COALESCE
 71

As palavras-chave e os parâmetros estão detalhados a seguir:

Palavra-chave Descrição
ADD DATAFILE Arquivos a serem acrescentados. Deve ser especificada sozinha.
RENAME DATAFILE Arquivos a serem renomeados. A TableSpace deve estar em modo
OFFLINE e o arquivo destino já deve existir. Deve ser especificada
sozinha.
COALESCE Compacta espaço nos arquivos. Deve ser especificada sozinha.
ONLINE Determina se a TableSpace estará disponível ou não (OFFLINE)
imediatamente após a criação. Deve ser especificada sozinha.
DEFAULT STORAGE Parâmetros de Armazenamento. Deve ser especificada sozinha.

NOTA
É possível listar os arquivos de dados para as TableSpaces. Basta selecionar a visão DBA_DATA_FILES.

16.6. Eliminação de Tablespaces

O comando DROP TABLESPACE, detalhado abaixo, permite eliminar a TableSpace
especificada. Por exemplo:

DROP TABLESPACE TBL_TESTE_2;

16.7. Exercícios

1. Crie uma TableSpace temporária em dois arquivos auto-expansíveis, tendo cada um o tamanho
de 500 KB. O tamanho máximo de cada arquivo será de 10M. O tamanho inicial dos EXTENTS
será de 100 KB, os seguintes de 200 KB e o crescimento percentual de 100%.

 Elabore um Script para criá-la.

 Verifique o sucesso da operação, comprovando a criação dos arquivos

2. Mova e renomeie um dos arquivos para outro diretório.

 Deixe a TableSpace indisponível.

 Mova fisicamente o arquivo para uma outra pasta.
 Renomeie o arquivo da TableSpace.
 Torne a TableSpace disponível.

3. Acrescente outro arquivo à TableSpace.

4. Apague a TableSpace.
 72
16.8. Criação de Tabelas com parâmetros de armazenamento

Com já foi mencionado anteriormente, as tabelas de um Banco são repositórios de dados, e na

verdade representam objetos que podem ser organizados por TableSpaces próprias, inclusive tabelas
com níveis de acesso diferentes também devem ser isoladas.
Uma tabela pode ser classificada de três formas diferentes:

 Aplicação: Tende a ser grande e muito consultada, e após a carga inicial, é pouco atualizada. Por
exemplo: CEPs
 Negócio: Bastante consultada, atualização moderada e possui uma taxa de crecimento muito
pequena. Por exemplo: Alunos e Instrutores.
 Transacional: Sofre inserções, atualizações e exclusões constantes. Por exemplo: Histórico.
Uma tabela é criada por meio do comando CREATE TABLE, que possui uma sintaxe
bastante ampla do que a já conhecida, ou seja, além da especificação de constraints e campos, é
possível detalhar a TableSpace, os Parâmetros de Armazenamento e os Parâmetros de Utilização de
Espaço em disco. Tais parâmetros determinam como serão configurados os blocos da tabela.
A sintaxe ainda simplificada do comando é mostrada abaixo:

CREATE TABLE nome

(campos, constraints)
TABLESPACE nome
PCTFREE inteiro entre 0 e 100
PCTUSED inteiro entre 0 e 100
INITRANS inteiro
MAXTRANS inteiro
STORAGE
(INITIAL inteiro [K | M]
NEXT inteiro [K | M]
MINEXTENTS inteiro
MAXEXTENTS inteiro
PCTINCREASE inteiro entre 0 e 100)

Exemplo:
CREATE TABLE cliente
(cd_cliente NUMBER(3), nm_cliente VARCHAR2(100))
TABLESPACE tbl_teste_2
PCTFREE 1
PCTUSED 10
INITRANS 1
MAXTRANS 255
STORAGE
(INITIAL 100K
NEXT 10k
MINEXTENTS 1
MAXEXTENTS UNLIMITED
PCTINCREASE 50)
 73

As palavras-chave e os parâmetros estão detalhados a seguir:

Palavra-chave / Parâmetro Descrição
NOME Nome da Tabela
CAMPOS, CONSTRAINTS Nome dos campos com respectivos tipos e constraints associados.
TABLESPACE Nome da TableSpace na qual estará inserido.
STORAGE Parâmetros de Armazenamento
Parâmetros de Utilização de Espaço em Disco
PCTFREE Número inteiro representando a procentagem de espaço deixado
livre para atualizações de campos com tamanho variável
(VARCHAR2, por exemplo)

Para determinar um valor razoável, deve-se analisar o

comportamento da tabela. Se houver muitos campos com tamanho
variável, recomenda-se um valor maior que 10%.
PCTUSED Percentual de espaço a ser deixado em cada bloco para atualização
dos campos de tamanho variável ou nulos.
INITRANS Número de transações por bloco. Min. 1
MAXTRANS Número máximo de transações simultâneas. Max. 255.
MINEXTENTS Quantos EXTENTS deverão ser alocados na criação de mais um
segmento para a tabela. Default:1.
MAXEXTENTS Quantidade máxima de EXTENTS alocados por segmento de tabela.
Default:10

NOTA
É aconselhável a criação das constraints da tabela em um script separado. Por exemplo, usando o
comando ALTER TABLE que será estudado posteriormente no decorrer desta seção. Abaixo segue o
exemplo do comando:

--CRIAÇÃO DA PK
ALTER TABLE cliente ADD CONSTRAINT PK_CLIENTE PRIMARY KEY (cd_cliente);

16.9. Alteração de Tabelas

A seguir, este material mostra uma série de comandos úteis para manutenir uma tabela.
Muitos deste comandos são utilizados durante a administração de um banco de dados, sem a
necessidade de recriar a tabela.

16.10.Adição de Colunas

Sintaxe: ALTER TABLE <TABELA>

ADD COLUMN <NOME_COLUNA> <TIPO> <RESTRIÇÃO>

Exemplo: ALTER TABLE CLIENTE ADD CPF VARCHAR2(14) NOT NULL

 74
16.11.Renomear Colunas

Sintaxe: ALTER TABLE <TABELA>

RENAME <NOME_ATUAL_COLUNA> TO <NOME_NOVO_COLUNA>

Exemplo: ALTER TABLE CLIENTE RENAME COLUMN CPF TO CPF_CLIENTE

16.12.Deleção de Colunas

Sintaxe: ALTER TABLE <TABELA>

DROP COLUMN <NOME_COLUNA>

Exemplo: ALTER TABLE CLIENTE DROP COLUMN CPF;

16.13.Adição de Constraints

16.14.Primary Keys

Sintaxe: ALTER TABLE <TABELA>

ADD CONSTRAINT <NOME_PRIMARY_KEY> PRIMARY KEY
(<CAMPO_CHAVE>)

Exemplo: ALTER TABLE CLIENTE ADD CONSTRAINT PK_CLIENTE PRIMARY

KEY (CD_CLIENTE);

16.15.Foreign Keys

Sintaxe: ALTER TABLE <TABELA_DESTINO>

ADD CONSTRAINT <NOME_FOREIGN_KEY>
FOREIGN KEY(<CAMPO_TABELA_DESTINO_CHAVE>)
REFERENCES <TABELA_ORIGEM> (<CAMPO_TABELA_ORIGEM_CHAVE>)

Exemplo: ALTER TABLE pedido

ADD CONSTRAINT fk_cliente_pedido
FOREIGN KEY (cd_cliente)
REFERENCES cliente (cd_cliente);

NOTA
Para consultar as constraints criadas no banco, basta listar os dados da visão DBA_CONSTRAINTS.
 75
16.16.Deleção de Constraints

Sintaxe: ALTER TABLE <TABELA>

DROP CONSTRAINT <NOME_CHECK_CONSTRAINT>

Exemplo: ALTER TABLE PEDIDO

DROP CONSTRAINT fk_cliente_pedido;

16.17.M odificação de Colunas

Sintaxe: ALTER TABLE <tabela> MODIFY coluna TIPO_DADO;

Exemplo: ALTER TABLE cliente MODIFY NM_CLIENTE VARCHAR2(200);

16.18.Desabilitar e Habilitar de Foreign Keys

Sintaxe: ALTER TABLE <TABELA>

MODIFY CONSTRAINT <NOME_CHECK_CONSTRAINT> ENABLE/DISABLE
[NOVALIDATE]; /*Cláusula NOVALIDATE usada somente para habilitar
uma FK*/

Exemplo: ALTER TABLE pedido MODIFY CONSTRAINT fk_cliente_pedido

DISABLE;

ALTER TABLE pedido MODIFY CONSTRAINT fk_cliente_pedido

ENABLE NOVALIDATE;

16.19.Apagar uma Tabela

Sintaxe: DROP TABLE <TABELA>

Exemplo: DROP TABLE PEDIDO;

16.20.Listar a estrutura de uma Tabela

Sintaxe: DESC <TABELA>

Exemplo: DESC PEDIDO;

NOTA
Existem algumas visões importantes para consulta de tabelas no banco de dados: DBA_TABLES e
USER_TABLES.
 76
16.21.Exercícios

1. Crie uma tabela com nome HISTORICO_PEDIDO, segundo os parâmetros abaixo:

 Tamanho do primeiro EXTENT: 32 K;

 Proximos: 16 K;
 Criada com 4 EXTENTS e não deve passar de 10;
 PCTINCREASE 50;
 PCTFREE e PCTUSED: 10 e 40 respectivamente;
 Verifique o sucesso da operação, comprovando a criação da tabela;
 Os campos da tabela são:
o ID_HSTR_PEDIDO NUMERICO DE 3
o ID_PEDIDO NUMERICO DE 7
o CD_CLIENTE NUMERICO DE 3
o DATA_HSTR_PEDIDO DATA
o DS_OBSERVACAO TEXTO DE 2000
2. Acrescente a Primary Key PK_HSTR_PEDIDO à tabela criada. O campo chave é
ID_HSTR_PEDIDO.

3. Liste a constraint de PK criada no exercício 4.

4. Execute o script de criação da tabela CLIENTE, usada como exemplo na seção 17.8.

5. Crie uma Foreign Key da tabela CLIENTE para tabela HISTORICO_PEDIDO, com o nome
FK_CLIENTE_HSTR_PEDIDO.

6. Insira centenas de registros na tabela recém-criada. Obs.: Utilize a rotina AlimentaHistorico.sql

7. Verifique o espaço ocupado. Obs.: Utilize a visão DBA_FREE_SPACE.

8. Apague a FK criada no exercício anterior.

9. Apague a tabela CLIENTE.

 77

16.22.Criação de Índices com parâmetros de armazenamento

Índices representam objetos de Banco de Dados úteis para acelerar operações de busca.
Imagine uma tabela grande (25 campos, 1.000 bytes por linha, 1.000 registros) criada pelo
comando abaixo:

create table TbExtensa (

campo01 char(40)
campo02 char(40)
...
Campo25 char(40));

Ao acessar o campo10, o Oracle precisa carregar as colunas campo1, campo2, ..., campo25.
Como cada registro ocupa 25 X 40 = 1.000 bytes, a leitura de 100 linhas provocaria a carga de
100.000 bytes.
Um índice representa uma estrutura “auxiliar”, que permite a origanização interna utilizando
árvores binárias para localizar rapidamente os dados [MOR 00].
Quanto à unicidade dos dados, índices podem ser de dois tipos [MOR 00]:

 UNIQUE: Valores únicos.

 NON-UNIQUE: Aceita valores duplicados.

Quanto á composição, índices podem ser de dois tipos:

 COMPOSTOS: Mais de um campo. Em um comando SELECT que faça filtros de linha ou

ordenações que utilizem campos pertencentes a índices compostos, deve-se colocar a coluna mais
utilizada primeiro.
 SIMPLES: Um campo apenas.
Os índices são criados é feita por meio do comando CREATE INDEX que possui uma sintaxe
bastante conhecida, pois é possível também especificar TableSpace e os Parâmetros de
Armazenamento (INITIAL, NEXT, etc.).

CREATE [UNIQUE] INDEX nome ON tabela

(campo ASC | DESC, ...campoN ASC | DESC)
TABLESPACE nome
PCTFREE inteiro entre 0 e 100
INITRANS inteiro
MAXTRANS inteiro
STORAGE
(INITIAL inteiro [K | M]
NEXT inteiro [K | M]
MINEXTENTS inteiro
MAXEXTENTS inteiro
PCTINCREASE inteiro entre 0 e 100)

Para remover os índices criados é usada a instrução DROP INDEX. Mas para isso é
necessário ter permissão para tal operação:
 78
DROP INDEX <NOME DO ÍNDICE>;

Existem motivos para criar índices em um banco de dados. Criamos índices quando a coluna
for usada freqüentemente na cláusula WHERE ou em uma condição de relacionamento, quando a
coluna contiver uma faixa ampla de valores, quando duas ou mais colunas forem usadas juntas com
freqüência em uma cláusula WHERE, ou em uma condição de relacionamento, ou quando uma
tabela for muito grande.

NOTA
Algumas visões podem ser usadas para conferir e acompanhar os índices de uma base de dados. São elas:
DBA_INDEXES e USER_INDEXES.

16.23.Exercícios

1. Crie uma TableSpace exclusiva de índices denominada TINDICES. Escolha os parâmetros de

armazenamento.

2. Crie um índice para a tabela HISTORICO_PEDIDO. Caso não exista, utilize o exercício 1 da
seção 16.10. O índice deve ter os seguintes parâmetros:

 Utilize a TableSpaces TINDICES ;

 O índice será composto pelos campos CD_CLIENTE e DATA_HSTR_PEDIDO;
 Tamanho do primeiro EXTENT: 64K;
 Próximos: 128K
 Criado com 2 EXTENTS e não deve ultrapassar de 15;
 PCTINCREASE de 0;
 PCTFREE: 10

3. Verifique a existência do índice criado.

 79

16.24.Restrições de Integridade

Em banco de dados relacional, normalmente existirão muitas relações, e as tuplas dessas

relações geralmente estão relacionadas de diversas maneiras. Porém, de uma maneira geral, existem
muitas limitações e restrições para os valores persistidos em um banco de dados. Essas restrições
são definidas através das regras do minimundo que o banco de dados representa.
Esta seção define os principais tipos de restrições, que geralmente podem ser divididas em três
grandes categorias [ELM e NAV 05]:

 Restrições inerentes ao modelo: São observadas durante o levantamento de requisitos do

sistema, e representam regras abstraídas do mundo real;

 Restrições baseadas em esquema (ou restrições implicitas): Restrições que podem ser
declaradas de forma não procedural na DDL (chave primária, integridade referencial, restrição de
domínio, etc.);

 Restrições baseadas em aplicação: Nesta categoria, enquadram-se todas as restrições que

devem ser explicitamente especificadas no SGBD em questão, através de programação, ou por meio
de instruções especiais;

16.25.Restrições baseadas em esquema

16.26.Restrições de Domínio

As restrições de domínio especificam dentro de cada tupla, o valor de cada atributo. Os tipos
de dados associados aos domínios incluem os tipos de dados numéricos padrões para inteiros (como
inteiro curto, inteiro e inteiro longo) e os números reais de ponto flutuante. Outros tipos de dados
também são disponibilizados em um SGBD, como, por exemplo, os tipos boleanos, data hora e em
alguns SGBDs, os tipos de dados moeda [ELM e NAV 05].

16.27.Restrições de Chave

Uma relação é definida como um conjunto de tuplas, e todos os elementos de um conjunto são
distintos, por isso, todas as tuplas da relação também devem ser distintas, ou seja, significa que duas
tuplas não podem ter a mesma combinação de valores para todos os seus atributos [ELM e NAV
05].
Para que ocorra unicidade e distinção entre as tuplas , é necessário a criação de uma chave ou
super-chave, chamada chave-primária. A chave primária permite criar a restrição de unicidade em
uma relação.
Existem outras formas de criar uma restrição de unicidade, quando, por exemplo, em uma
mesma relação existe uma chave primária, mas também existe outro atributo que não pode ter os
dados repetidos. Neste caso cria-se um índice único para este atributo, respeitando a restrição.
 80
16.28.Check Constraint

Uma check constraint, é um exemplo de restrição baseada em esquema e de domínio. Esta

restrição é declarativa e usa expressão boleana, que deve ser verdadeira para todas linhas de uma
tabela (valores de uma coluna)

Sintaxe: ALTER TABLE <TABELA>

ADD CONSTRAINT <NOME_CHECK_CONSTRAINT>
CHECK (<NOME_COLUNA_CHECK> <CLAUSULA>)

Exemplo: ALTER TABLE cliente

ADD CONSTRAINT ck_cliente_tp_sexo
CHECK (tp_sexo in ('F','M')) ;

ALTER TABLE cliente

ADD CONSTRAINT ck_cliente_cd_cliente
CHECK (cd_cliente <> 0) ;

16.29.Restrições baseadas em aplicação

Como foi dito anteriormente, as restrições baseadas em aplicação devem ser explicitamente
especificadas no SGBD por meio de programação, ou por meio de instruções especiais. A seguir
serão mostradas as sintaxes e comandos usados para se criar restrição baseadas em aplicação.

16.30.Assertion

Especificação declarativa de uma expressão boleana que deve ser verdadeira para toda a base
de dados (pode envolver várias tabelas). A restrição é criada sem depender de uma tabela
específica. Por exemplo, um cliente não pode ser um vendedor:

CREATE ASSERTION CK_ASS_CLIENTENAOVENDEDOR

(
NOT EXISTS (SELECT CLI.CPF FROM cliente CLI
INTERSECT
SELECT VEND.CPF FROM vendedor VEND)
)

16.31.Triggers ou Gatilhos

Trigger ou gatilho é um mecanismo para tratar alterações no Banco de Dados. Deve ser
utilizado com cuidado, ou seja, em um ponto de execução de uma trigger pode ocorrer de outra
trigger ser “disparada”, ou até a mesma (triggers recursivas).
O uso comum de triggers é manter a consistência do Banco de Dados. Em muitos casos, pode-
se utilizar uma restrição para atingir o mesmo objetivo. Porém as triggers são mais flexíveis, vão
além de manter integridade, pois também podem ser utilizadas para estatísticas, e inserir dados de
auditoria das inserções ou alterções na base de dados.
Um exemplo prático do uso de triggers seria em um controle academico. Ao excluir uma
turma seria desejável eliminar automaticamente as entradas desta turma na tabela de Horários; ou
 81
caso existam tabelas que representem itens avaliados pelos alunos que, ao matricular um aluno,
sejam inseridos tantos registros quantos forem os itens para a realização da avaliação [MOR 00].
Triggers são objetos do banco de dados que representam unidades de programas que são
executados, automaticamente, antes ou depois de um comando DELETE, INSERT ou UPDATE.
As vantagens obtidas na utilização de triggers são várias:

 O controle da Integridade Referencial é facilitado: Pode-se permitir ou não que inclusões,

alterações ou exclusões ocorram em cascata;

 A crítica aos dados oferece mais possibilidades do que a realizada via constraints ;

 Acessos que alterem linhas de uma tabela podem ser registrados em outra (auditoria);

 A performance é otimizada, já que o processamento ocorre, automaticamente, no Servidor;

Antes de definir uma Trigger, deve-se compreender três características básicas:

Ação Representa o comando que provocou a execução da trigger: INSERT,

UPDATE ou DELETE. Nada impede que exista uma trigger que responda a
dois, mesmo três comandos.
Escopo Indica se o código contido na trigger será executado para cada linha
afetada ou apenas uma vez. (FOR EACH ROW ou STATEMENT).
Tempo Indica se a execução ocorrerá antes ou depois da ação (BEFORE ou
AFTER).

Durante a execução de uma trigger que afete várias linhas , pode-se, eventualmente, consultar
ou modificar os valores antigos e novos da linha sendo alterada. Existem duas variáveis de
ambiente que representam a linha prévia (:old) e a posterior à alteração (:new). Porém, deve-se
observar as regras abaixo [MOR 00]:

 Em triggers com o tempo BEFORE, pode-se tanto alterar como consultar :new;

 Em triggers com o tempo AFTER, pode-se apenas consultar :new;

 Em triggers com o escopo STATEMENT, a utilização de :new e :old é proibida;

16.32.Criação de Triggers

Para se criar uma trigger, deve-se editar um arquivo texto contendo o comando com a sintaxe
abaixo:

CREATE OR REPLACE TRIGGER nome_trigger [before | after]

[insert or delete or update] [of column]
on tabela
[for each row]
begin
bloco PL/SQL
end;
 82

Exemplos:

CREATE OR REPLACE TRIGGER trg_update_cliente

AFTER UPDATE ON cliente FOR EACH ROW
BEGIN
IF :NEW.cd_cliente = '0' THEN
DBMS_OUTPUT.PUT_LINE('Tentativa de incluir valor igual a
zero para o código de cliente');
END IF;
END;
/

CREATE OR REPLACE TRIGGER trg_update_cliente

AFTER UPDATE OF cd_cliente ON cliente
REFERENCING NEW AS N
OLD AS O
FOR EACH ROW
WHEN (N.cd_cliente = '0')
BEGIN
IF UPDATING THEN
DBMS_OUTPUT.PUT_LINE('Tentativa de incluir valor igual a
zero para o cliente com o nome :'||:O.NM_CLIENTE);
END IF;
END;
/

NOTA
Para desabilitar ou habilitar uma trigger basta usar o seguinte comando:

ALTER TRIGGER trg_update_cliente DISABLE;

A seguir serão mostrados alguns exemplo do uso de triggers em cada ação.

16.33.Criação de Triggers com INSERT

CREATE OR REPLACE TRIGGER trg_insert_vendedor

BEFORE INSERT ON vendedor FOR EACH ROW
DECLARE
novo_cd_vendedor NUMBER(10);
BEGIN
SELECT SQ_VENDEDOR.NEXTVAL
INTO novo_cd_vendedor FROM DUAL;

:NEW.cd_vendedor:= novo_cd_vendedor;
END;
/
 83

NOTA
Para execução da trigger anterior seria necessário a criação de uma sequence. O código abaixo mostra
esta criação:

create sequence sq_vendedor

start with 1
increment by 1
maxvalue 999999999

16.34.Criação de Triggers com UPDATE

CREATE OR REPLACE TRIGGER trg_upd_auditoria_vend

BEFORE UPDATE ON vendedor
FOR EACH ROW
DECLARE
QTDE_VENDEDOR_AUDITORIA NUMBER(10);
BEGIN

SELECT COUNT(1)
INTO QTDE_VENDEDOR_AUDITORIA
FROM AUDITORIA_VENDEDOR
WHERE CD_VENDEDOR = :OLD.CD_VENDEDOR;

IF QTDE_VENDEDOR_AUDITORIA = 0 THEN

INSERT INTO AUDITORIA_VENDEDOR (CD_VENDEDOR,

ATUALIZACAO_VENDEDOR) VALUES (:OLD.CD_VENDEDOR, 1);

ELSE

UPDATE AUDITORIA_VENDEDOR
SET ATUALIZACAO_VENDEDOR = ATUALIZACAO_VENDEDOR + 1
WHERE CD_VENDEDOR = :OLD.CD_VENDEDOR;

END IF;

END;
/

16.35.Criação de Triggers com DELETE

CREATE OR REPLACE TRIGGER trg_delete_vendedor

BEFORE DELETE ON vendedor FOR EACH ROW
BEGIN
DELETE FROM AUDITORIA_VENDEDOR
WHERE CD_VENDEDOR = :OLD.CD_VENDEDOR;
END;
/
 84

16.36.Segurança e Nível de Acesso

A razão de ser de um Banco de Dados e seu DBA são os usuários. Tudo o que o DBA faz, em
última análise, tem por objetivo atender às necessidades do usuário. Infelizmente, nem sempre a
relação DBA-usuário é muito amistosa. O objetivo do DBA é atender aos usuários, e ele deve
adaptar da melhor forma às necessidades deles [MOR 00].
Para que o DBA possa atender os anseios dos usuários, ele deve conhecer em detalhes as
seguintes questões:

 O que o usuário que?

 O que o usuário precisa?
 Existe outro usuário que queira ou necessita o mesmo?
 Qual seria o nível mínimo de segurança aceitável?
 E o máximo?
 Existem regras na empresa que restrinjam a utilização do Banco pelo usuário?

Um dos pontos fortes do Oracle XE é a segurança que ele oferece na manipulação de objetos.
Uma tabela, view ou synonym somente pode ser manipulado ou acessado por outros usuários caso o
dono ou o DBA dê o acesso.
Para entendimento melhor sobre segurança e nível de acesso, alguns conceitos devem ser
esclarecidos:
Conceito Descrição
Usuário Indivíduo que se conecta ao Banco e utiliza objetos dele. Também
pode criar objetos e permitir que outros usuários manipulem.
Schema Conjunto de objetos (tabelas, índices, visões, etc.) de um usuário.
Pode ser listado com o comando: SELECT * FROM CAT;
Privilégio Direito que um usuário recebe para fazer algo.
Papel (role) Conjunto de privilégios agrupados e com um nome. Facilita
bastante a gerência de privilégios.

O DBA deve saber criar usuários (comando CREATE USER), atribuir-lhes privilégios de
sistema ou objeto e, de preferência, criar papéis (roles) que concentrem grupos de privilégios que
possam ser atribuídos a mais de um usuário.

16.37.Usuários

Geralmente, quem cria usuários é o DBA, ou alguém designado por ele, e com privilégio para
tal. A sintaxe simplificada do comando cria usuários é a seguinte:

CREATE USER nome

IDENTIFIED BY senha
DEFAULT TABLESPACE nome
TEMPORARY TABLESPACE nome
QUOTA inteiro [K | M] on tablespace
 85

Em que:
Nome Identificação do usuário criado
Senha Senha com, no mínimo, seis caracteres, podendo conter números ou
letras. Não devem ser óbvias e freqüentemente devem ser alteradas.
Default tablespace TableSpace destino de tabelas ou índices criados pelo usuário,
quando outra não for especificada.
Temporary TableSpace temporária utilizada pelos comandos emitidos pelo
tablespace usuário.
quota Espaço que pode ser utilizado em determinada TableSpace.

Exemplo:

CREATE USER evaldo

IDENTIFIED BY #$%76
DEFAULT TABLESPACE user_data
TEMPORARY TABLESPACE temporary_data
QUOTA 1 M ON user_data;

NOTA
Para comprovar a existência de um usuário, pode-se utilizar a visão ALL_USERS.

Usuários DBA possuem privilégios de sistema para mudar senhas, ou o próprio usuário, pode
alterar a senha de acesso ao Oracle XE, utilizando o comando ALTER USER. Por exemplo:

ALTER USER evaldo IDENTIFIED BY 12345;

Usuários também pode ser apagados. É bom observar que todos os objetos criados por ele
também podem ser apagados, usando a seguinte de linha de comando:

DROP USER evaldo CASCADE;

Evidentemte, nem todos usuários tem o direito de apagar outros usuários. Somente aqueles
que tiverem direito para tal.

16.38.Privilégios de Sistema

Ao ser criado, um usuário não tem direito nem de se conectar. Para que possa ser considerado
como um usuário, ele deve receber alguns privilégios de sistema. Veja alguns exemplos:
 create session
 create table
 alter table
 create sequence
 create view
 create user
 drop user
 86

Ainda existem outros, por exemplo:

 drop any table

 select any table
 alter any sequence
 backup any table
 create any view
 lock any table

Para conceder privilégios de sistema ou qualquer outro tipo de privilégio, deve-se utilizar o
comando GRANT, cuja sintaxe é:

grant {privilégio [, privilégio, ...]} to {usuário [, usuário] |

role | public}

em que:

privilégio São os privilégios de sistema aos quais o usuário terá direito.

Usuário Quem receberá os privilégios.
Role Também podem ser concedidos privilégios a roles, representando
uma forma de agrupá-los, para que possam ser atribuídos de uma
vez a usuários.
Public Concede os privilégios a todos os usuários do banco.

Uma vez criado o usuário, ele deve receber privilégios de conexão. Para que o usuário possa
“logar” no banco, deve-se conceder o privilégio de SESSION.

NOTA
Para comprovar a existência de um usuário, pode-se utilizar a visão ALL_USERS.

Para visualizar os privilégios de sistema, devem-se investigar as visões USER_SYS_PRIVS

e DBA_SYS_PRIVS (esta para usuários com status de DBA).

16.39.Privilégios de Objeto

Privilégios de obejto servem, basicamente, para que outros usuários, que não o dono, ou
aqueles que tenham privilégios de sistema de tipo ANY, possam ler, alterar ou até mesmo apagar
linhas de tabelas. Os privilégios de obejto são:
 87
Privilégio Tabela View Sequence Procedure
alter X X
deleted X X
execute X
index X
insert X X
references X
select X X X
update X X
all X X X X

Para conceder privilégios de objeto, também utilizamos o comando GRANT. Sua sintaxe é:

grant {privilégio [, privilégio, ...]} [(coluna1,

coluna2...colunaN)] on objeto to {usuário [, usuário] | role |
public}

Exemplo:

grant select, insert on historico_pedido to evaldo

Ainda podem-se conceder privilégios por campo. Por exemplo:

grant update (data_hstr_pedido) on historico_pedido to evaldo

Para visualizar os privilégios de objetos, devem-se investigar as visões USER_COL_PRIVS,

e USER_TAB_PRIVS. Por exemplo:

SELECT GRANTEE, TABLE_NAME, GRANTOR, PRIVILEGE FROM

USER_TAB_PRIVS;

NOTA
É possível retirar algum privilégio de objeto. Para isso pode-se usar o comando REVOKE:

REVOKE UPDATE ON HISTORICO_PEDIDO FROM Evaldo;

16.40.Roles

Role é um grupo de privilégios (sistema ou objeto), reunidos sob um único nome, que pode
ser concedido a um ou mais usuários. O Oracle XE já oferece algumas roles predefinidas. Por meio
da visão DBA_ROLES é possível identificá- la, por exemplo:

SELECT * FROM DBA_ROLES;

Toda ROLE é pública. Não se trata de um objeto que pertença a alguém. Quem tiver
privilégio para criar roles, o faz com o comando abaixo:

CREATE ROLE nome_role;

Uma vez criada, uma role pode receber privilégios e ser concedida a uma usuário:
 88
CREATE ROLE GERENCIA;
GRANT CREATE TABLE, CREATE VIEW TO GERENCIA;
GRANT GERENCIA TO evaldo;

NOTA
Para visualizar roles, devem-se investigar as visões USER_ROLE_PRIVS e ROLE_ROLE_PRIVS ;

Também é possível retirar privilégio de roles, ou até mesmo retirar a role de um usuário.
Desta forma, utiliza-se o comando revoke:

REVOKE CREATE VIEW FROM GERENCIA;

REVOKE GERENCIA FROM EVALDO;

16.41.Exercícios

1. Crie um usuário com o nome EXERC1618.

2. Atribua ao usuário EXERC1618 o direito de CREATE SESSION.

3. Conecte como EXERC1618 e liste todos os usuários do banco.

4. Liste todos os privilégios de sistema que o usuário EXERC1618 recebeu.

5. Crie uma role com o privilégio de CREATE USER. Atribua a role criada ao usuário
EXERC1618.

6. Por meio do usuário EXERC1618, crie o usuário EXERUSUA.

 Retire o direito de criação de usuário de EXERC1618.

 89

16.42.Cópias de Segurança e Restauração de Banco de Dados

Talvez os momentos de maior angústia de um DBA sejam causados por problemas de

Backup, ou seja, centenas de usuários precisando acessar o Banco e este, parado. Não é interessante
para o DBA que as rotinas de Backup ou Importação/Exportação sejam executadas em horário
administrativo. No entanto, o DBA deve cuidar da integridade do banco de dados e a recuperação
do mesmo caso haja danos ou situações não previstas [MOR, 2000].
Qualquer problema que ocorra com a consistência do Banco é, em última análise, culpa do
DBA. É de responsabilidade dele que o Banco esteja sempre “saudável” e, caso ocorram perdas, e
que a recuperação seja o mais rápido e transparente possível.
Deve-se manter uma rigorosa política de cópias de segurança e simulações de perdas. Uma
política de Backup validada seria como ter botes salva-vidas em uma navio. Espera-se nunca
precisar deles, mas quando forem necessários, têm de estar a postos e resolver a situação.
Ao estabelecer uma política de backup, devemos responder às quatro perguntas seguintes
[MOR, 2000]:

 O que copiar?
 Qual a freqüência da realização das cópias?
 Quem deve realizar as cópias?
 Destino isto é, para onde (Disco, Fita)?

16.43.Exportação de Banco de Dados

É possível realizar cópias ou exportação de dados por diversas razões: segurança, necessidade
de migração de dados (base de produção / base de desenvolvimento), necessidade de desfragmentar
tabelas, transporte de schemas [MOR, 2000].
O utilitário de exportação trabalha em três modos:

 FULL: copia todos os Schemas. Permitido somente para quem tiver o papel
EXP_FULL_DATABASE;
 USER: copia um Schema;
 TABLE: copia uma tabela que pertença a uma dado Schema.

A exportação pode ser realizada pelo utilitário EXP. Por exemplo:

EXP system/1234 file = c:\auladba.bkp compress=Y owner=evaldo log

= c:\auladba.txt

16.44.Importação de Banco de Dados

A importação somente faz sentido se houver um arquivo produzido pelo utilitário de

exportação, e recomenda-se a usuários que desejam transportar seu Schema.
O utilitário de importação também trabalha em três modos: full (necessário o papel
IMP_FULL_DATABASE), user e table; além disso, pode ser Completa, Incremental ou
Cumulativa.
 90
A importação pode ser realizada pelo utilitário IMP. Por exemplo, imagine que tivessem sido
perdidas as tabelas exportadas, o comando seria:

IMP system/1234 file = c:\auladba.bkp buffer = 64000 commit

= Y ignore = y fromuser = evaldo touser = auladba

NOTA
É recomendado que a exportação e importação sejam feitas somente com o us uário DBA.

16.45.Comandos para Backup e Restore

Esta seção descreve os passos necessários para efetuar um backup e uma restore no banco de
dados. O Oracle XE possibilita a realização de backup e a restauração do banco de dados de forma
muito simples, baseado na proteção física dos arquivos feitos pelo banco de dados, incluindo os
seguintes arquivos [SIL, 2007]:

 arquivos de dados (datafiles)

 o arquivo de controle (controlfile)
 o arquivo de parâmetros do servidor
 os arquivos de log (histórico de modificações que ocorrem na base)

Para incluir os arquivos de log, o banco de dados deve estar em modo de arquivamento, do
tipo ARCHIVELOG. No Oracle 10 XE, o backup é efetuado por scripts prontos do RMAN
(Recovery Manager), que é uma aplicação desenvolvida especificamente para backup e recover de
banco de dados Oracle [SIL, 2007].
O padrão do banco de dados que é criado no Oracle XE é o modo NOARCHIVELOG,
fazendo com que não sejam armazenados os arquivos de Logs. Nesta forma de trabalho, quando a
instância tiver algum dano, o DBA não conseguirá voltar completamente com todos os dados até o
último instante do problema ocorrido. Neste caso todas as transações e objetos deverão ser refeitos.
Para se utilizar o RMAN, o DBA deve-se trocar a opção NOARCHIVELOG para ARCHIVELOG,
seguindo orientações da Oracle. Em seguida, poderá retornar com a opeção anterior.
A rotina abaixo mostra os comandos básicos para a execução de backups e recoveries no
Oracle XE por meio do utilitário RMAN. Cada linha de comando está comentada explicando a
sintaxe de execução:

------------------------------------------------------------------
/*
1-)O comando ALTER SYSTEM permite alterar os parâmetros de
sistema.
O parâmetro DB_RECOREY_FILE_DEST, especifica a localização padrão
para área de recuperação de backup. A área de recovery contém a
cópia de arquivos de controle, logs e arquivos de dados.
Obs.: Deve-se logar com o usuário SYS como SYSDBA.
*/
------------------------------------------------------------------
ALTER SYSTEM SET DB_RECOVERY_FILE_DEST = '/';
------------------------------------------------------------------
 91

/*
2-) O parâmetro DB_RECOREY_FILE_DEST_SIZE, especifica (em bytes) o
limite máximo da área estabelecida no parâmetro
DB_RECOREY_FILE_DEST para backup e restauração de dados.
*/
------------------------------------------------------------------
ALTER SYSTEM SET DB_RECOVERY_FILE_DEST_SIZE = 2G;
------------------------------------------------------------------

/*
3-)Desativa o banco de dados. Esta operação deve ser executada
caso o banco de dados esteja com opção NOARCHIVELOG. Caso
contrários os comandos enumerados como 3, 4, 5 e 6 não devem ser
executados.
*/
------------------------------------------------------------------
SHUTDOWN;
------------------------------------------------------------------

/*
4-) Para habilitar a opção ARCHIVELOG, o banco de dados deve ser
iniciado sem montar os arquivos de sistema.
*/
------------------------------------------------------------------
STARTUP NOMOUNT;
------------------------------------------------------------------

/*
5-) Em seguida deve-se mudar o stauts do banco de dados para
MOUNT.
*/
------------------------------------------------------------------
ALTER DATABASE MOUNT;
---------------------------------------------------------- --------

/*
6-) Em seguida deve-se estabelecer a mudança para ARCHIVELOG.
*/
------------------------------------------------------------------
ALTER DATABASE ARCHIVELOG;
------------------------------------------------------------------
 92

/*
7-) Em seguida o DBA deve logar no utilitário RMAN, por meio do
PROMPT do DOS, basta digitar “RMAN TARGET /”. A seguir são
definidos cada comando usados na execução do BACKUP incremental:

A-) RUN {} - Utilizado para agrupar um conjuntos de comandos do

RMAN e executados de forma seqüencial.

B-) RECOVER COPY OF DATABASE – Restaura uma cópia do banco de

dados para o nome de TAG especificado, o qual será mencionado no
comando de BACKUP.

C-) BACKUP INCREMENTAL LEVEL 1 - Somente os blocos de dados

alterados.

*/
------------------------------------------------------------------
RUN {
RECOVER COPY OF DATABASE WITH TAG 'backup';
BACKUP INCREMENTAL LEVEL 1 FOR RECOVER OF COPY WITH TAG 'backup'
DATABASE;
}

/*
8-) Para recuperar o backup, basta digitar o comando abaixo.
*/
------------------------------------------------------------------
RESTORE DATABASE;
------------------------------------------------------------------

NOTA
É possível listar de arquivos de dados e arquivos temporários por meio do RMAN. Basta di gitar o comando
REPORT SCHEMA. Desta forma, é possível analisar o arquivo de dados que pode ser recuperado
separadamente.

/*
9-) Para recuperar um DATAFILE específico.
*/
------------------------------------------------------------------
RECOVER DATAFILE 2;
------------------------------------------------------------------

16.46.Exercícios

1. Execute os passos do exemplo mostrado na Seção 16.7.3.

 93

16.47. Comando COPY

O comando COPY é um utilitário usado para copiar dados entre duas bases de dados por meio
do aplicativo SQLPlus.O comando COPY copia dados de uma instância para outra por meio de uma
conexão tanto no servidor quanto no client Oracle.
Os parâmetros do utilitário COPY são:

 create: Se a tabela no destino já existe, o utilitário COPY emite um erro, se a tabela não existir
ele cria a tabela e copia os dados.

 replace: Se a tabela no destino já existe, o utilitário faz o “drop” e “create” da tabela e copia os
dados novos para a tabela.

 insert: Se a tabela de destino já existe, o utilitário COPY tenta inserir novas linhas na tabela. Se
já houver linhas na tabela, o COPY emite um erro e aborta a operação.

 append: Insere as linhas que faltam na tabela de destino e que estão contidas no arquivo de
input.

Exemplo:

copy from system/1234@l3maq01 to system/1234@l3maq02 create

cliente_l3maq02 using select * from cliente;
 94

16.48.Criando Database Links

Um database link é um objeto criado em um esquema de um banco de dados que possibilita o

acesso a objetos de outro banco de dados, seja ele Oracle ou não. Esse tipo de sistema é conhecido
como Sistema de Banco de Dados Distribuídos e pode ser Homogêneo – quando acessa outros
bancos de dados Oracle - e Heterogêneo, caso contrário. Para acessar bancos de dados que não
sejam Oracle é necessário utilizar uma aplicação chamada Oracle Heterogeneous Services em
conjunto com um agente.
O Heterogeneous Services é um componente integrante do Oracle Server, que uma arquitetura
comum e mecanismos de administração para os produtos da Oracle, além de outras facilidades de
acesso a bancos heterogêneos.
Para acessar um banco de dados não Oracle utilizando, deve-se selecionar uma aplicação
específica do sistema, ou seja, cada banco de dados específico requer um agente diferente. Por
exemplo, para criar um database link com um banco de dados Sybase é necessário obter um
gateway transparente específico para Sybase.. O agente executa comandos SQL e requisições de
transações a bancos de dados não Oracle em nome do usuário da base de dados Oracle.
Pode-se, também, utilizar uma conectividade genérica para acessar bancos de dados não
Oracle, como os protocolos ODBC ou OLE DB, através do uso dos Heterogeneous Services ODBC
e OLE-DB, sem a necessidade de adquirir e configurar um agente específico para o banco de dados
que se deseja acessar.
Porém, esta seção se limita ao acesso a banco de dados homogêneos. Ao criar um database
link é possível utilizar e referenciar tabelas e visões do outro banco de dados, acrescentando ao final
do nome destes objetos @nome_do_dblink.
Com o dblink e os privilégios necessários é possível utilizar comandos SELECT, INSERT,
UPDATE, DELETE ou LOCK TABLE sobre os objetos desejados do banco de dados remoto,
sabendo que uma transação do banco de dados irá incluir os comandos DML (linguagem de
manipulação de dados) direcionados a dblinks, tornando as operações de COMMIT e ROLLBACK
sobre tais bases, transparente.
Para a criação de um database link alguns pré-requisitos devem ser observados, como por
exemplo, o usuário que irá criar o database link precisa ter o privilégio de sistema CREATE
DATABASE LINK (para database links privados) ou CREATE PUBLIC DATABASE LINK (para
database links públicos), além do privilégio de sistema CREATE SESSION no banco de dados
Oracle remoto.
A criação de um database link é realizada conectando-se no banco de dados local com um
usuário que possua os privilégios necessários e executando o comando abaixo:

CREATE DATABASE LINK nome_do_dblink

CONNECT TO usuário_banco_remoto IDENTIFIED BY “senha”
USING 'connect_string';

Exemplo:

CREATE DATABASE LINK LINK_BD_COMERCIAL

CONNECT TO USER_LINK_COMERCIAL IDENTIFIED BY “COM_LINK”
USING 'COMERCIAL';

Para testar se o dblink foi criado com sucesso pode-se utilizar o seguinte comendo SELECT:

SELECT * FROM cliente@LINK_BD_COMERCIAL;

 95

NOTA
Para manter-se a transparência no acesso a objetos de outros bancos de dados pode-se criar sinônimos
públicos para os objetos acessados através remotamente.

Sintaxe do comando:

CREATE [OR REPLACE] PUBLIC SYNONYM { NOME_SYNONIMO_OB JE TO} FOR {NOME_OBJETO};

Exemplo:

CREATE OR REPLACE PUBLIC SYNONYM CLIENTE FOR CLIENTE@LINK_B D_COME RCIA L;

16.49.Exercícios

1. Crie a tabela cliente detalhada na seção 16.8 com o nome CLIENTE_{COMPUTADOR}. Onde
COMPUTADOR é o número da máquina do laboratório do curso.

2. Crie um usuário para servir acessar a tabela do banco de dados remoto. O nome do usuário será
USUA_{COMPUTADOR}. O usuário deve ter direito de CREATE SESSION, direito de SELECT
na tabela criada.

3. Crie um DatabaseLink apontando para algum computador do laboratório.

4. Faça uma SELECT, po meio do dblink, na tabela CLIENTE_{COMPUTADOR}.

5. Crie um sinônimo público para a tabela CLIENTE_{COMPUTADOR} acessada pelo dblink.

6. Execute a instrução SELECT no sinônimo criado.

 96

Referências

[ELM e NAV 05] ELMASRI, Ramez; NAVATHE, Shamkant B. Sistemas de Banco de Dados.
São Paulo: Addison Wesley, 2005.

[HEU 98] HEUSER, Carlos Alberto. Projeto de Banco de Dados. Porto Alegre: Sagra Luzzatto,
1998.

[MOR 00] MORELLI, Eduardo Terra. Oracle 8 SQL, PL/SQL & Administração. São
Paulo:Érica, 2000.

[ORA 07] Oracle8 Server SQL Reference. Disponível em : http://download-east.oracle.com/docs

/cd/A58617_01/server.804/a58225/toc.htm. Acesso em 10 de fev 2007.

[PRE 06] PRESSMAN, Roger S. Engenharia de Software. 6 ed. São Paulo: McGraw-Hill, 2006.

[SER e REZ 06] SERSON, Roberto R.; REZENDE, Ricardo. Oracle 11g Express Edition.
SQLMagazine, Rio de Janeiro, v. 37, p. 34 – 39, 2006.

[SIL 07] SILVA, Robson Soares. Oracle 11g Express Edition. São Paulo: Érica, 2007.

[WAZ 04] WAZLAWICK, Raul Sidnei. Análise e Projeto de Informação Orientados a Objetos.
Rio de Janeiro: Campos, 2004.