CURSOS

CONSULTORIA
Introdução ao Oracle
modelagem de dados
SQL e PL/SQL
(Módulo Básico)
 Objetivo
- introduzir os conceitos de modelagem de dados
- mostrar os comandos SQL e PL/SQL
- técnicas para melhorar desempenho
- introduzir o catálogo do Oracle
 Banco de Dados
definição 1

“Coleção de dados fortemente

estruturados acompanhados de um
conjunto de mecanismos de controle,
acesso e manipulação”.
[Prof. Sérgio Lifschitz e outros – ATBD – PUC-Rio – 2000]
 Banco de Dados
definição 2

“Um Banco de Dados é uma coleção de

dados relacionados. Dados são
definidos como fatos conhecidos que
podem ser armazenados e que
possuem um significado implícito”.
[Elmasri e Navathe – Fundamentals of Database Systems – 2000]
 SGBD

- Sistema que permite ao usuário acessar

os dados armazenados no Banco de Dados.
- O SGBD faz a interface entre o usuário e
o Banco de Dados.
 Bancos de Dados
- Relacionais
- Orientados a Objeto
- Estendidos (ou objeto-relacional)
- Multimídia
- Informação Geográfica (GIS)
- Data warehouses e OLAP
- Dedutivo
- Outros
 O SGBD Oracle

- Oracle 7 = última versão totalmente relacional

- Oferece uma linguagem de BD: o PL/SQL
- Na versão 8, um banco de dados estendido
- Total compatibilidade com o universo relacional
 Modelagem Conceitual
- Modelo de Dados
- Esquema de Dados
- Instância de um banco de dados
- Modelos Lógicos
- Esquema (Lógico)
- Modelos e Esquemas Conceituais
- Modelos e Esquemas Internos
Arquitetura em três níveis
Projeto de Bando de Dados
 Esquema ER
CHEN

Diferença entre o modelo e esquema:

Modelo é um conjunto de ocorrências.
Esquema é o produto feito a partir do modelo.
ESTADO = Conj. “REGISTROS” de um BD.
 Esquema ER
“Pé de galhinha”

-Modelo mais usual

-Mais fácil de manipular
 Esquema ER - Dependência
É a quantidade de vezes que uma instância deve se
relacionar com outra

Dependência total X Dependência parcial:

Total: linha dupla (Chen) / Linha contínua (Pé de Galhinha)
Parcial: linha simples (Chen) / tracejada (Pé de Galhinha)
 Esquema ER - Cardinalidade
quantas ocorrências de uma Entidade participam
no mínimo e no máximo do relacionamento

- MÍNIMA é número mínimo de vezes que uma

instância se relaciona com outra (pode ser 0 ou 1)

- MÁXIMA é o número máximo de vezes que uma

instância se relaciona com outra (pode ser 1 ou N)
 Esquema ER - Entidade Fraca
É uma entidade que depende da existência de outra

A entidade da qual a entidade fraca depende é

chamada forte ou proprietária

É representada por um retângulo duplo

É representada por um retângulo duplo

Esquema ER - Relacionamento Ternário
Logística de fornecimento direto de produtos aos clientes
de fornecedores parceiros – Caso Ponto Frio.

CLIENTE FORNECEDOR

N 1

FORNECIMENTO

M
PRODUTO

Não é possível representar um relacionamento

ternário através de dois ou três binários.
 Esquema ER - Agregado

N M
CLIENTE CONTA
POSSUI

TEM

CARTAO
Esquema ER - Auto-Relacionamento

EMPREGADO 1
SUPERVISAO
SUPERVISOR

SUBORDINADO
 Esquema ER
Generalização e Especialização

EMPREGADO

SECRETARIA TECNICO ENGENHEIRO

(D) significa disjunção.

(C) significa conjunção.
 Projeto Lógico
Relação = Tabela - ou arquivo (por analogia)

Exemplo: Relação FORNECEDOR

CODFORN FNOME ENDEREÇO STATUS FCIDADE

F1 N1 E1 50 C1
F2 N2 E2 55 C2
F3 N3 E3 45 C3
F4 N4 E4 21 C4
F5 N5 E5 18 C5
F6 N6 E6 15 C6
F7 N7 E7 11 C7
 Projeto Lógico – continuação 1

As colunas são os atributos.

As linhas são as tuplas.
As tuplas são as instâncias do modelo E-R.
Os atributos possuem domínios (invioláveis)
Grau é o número de atributos da Ralação
Cardinalidade é o número de tuplas da Relação
 Projeto Lógico – continuação 2

- DML (Linguagem de Manipulação de Dados)

INSERT, UPDATE, ...
- DDL (Linguagem de Definição de Dados)
CREATE, DROP, ...
- DCL (Linguagem de Controle de Dados)
GRANT, REVOKE, ...
 Projeto Lógico
Características das relações

1) Não há tuplas duplicadas;

2) Não há ordem entre os atributos;
3) Não há ordem entre as tuplas;
4) Não pode haver vetores nas relações.
 Projeto Lógico
Regras de integridade

Integridade de Domínio
Integridade de Chave
Integridade de entidade
Integridade Não Nulo
Integridade Referencial
 Mapeamento:
Esquema ER  Relacional
- entidades se torna relação
- atributos da entidade  atributo da relação
- vetores se transformam em novas entidades
- relacionamentos:
evitar nulos
evitar vetores
representar cardinalidade
manter simplicidade
 Normalização

Objetivo de minimizar as anomalias:

- Minimizar redundâncias e inconsistências
- Facilitar a manipulação dos dados
- Facilitar a manutenção
 Normalização - Anomalias
Código Nome Cargo Setor Qtd_Funcionarios

1 Aline Gerente Vendas 33

2 Gisele Programador Suporte 20

3 Luciana Analista Compras 1

4 Maria Programador Suporte 20

5 Paula Gerente RH 6

Anomalia de Exclusão  código=3, setor desaparece

Anomalia de Alteração  Suporte em várias linhas
Anomalia de Inclusão  + 1 funcionário p/ Suporte
 1FN
Uma relação está na 1FN se, e somente se, todos os
domínios básicos contiverem somente valores
atômicos (não possuem atributos multivalorados).
Para atingir esta forma normal devemos eliminar os
vetores (atributos multivalorados).
Procedimentos:
a) Identificar a chave primária;
b) Identificar o atributo multivalorado e excluí-lo;
c) Criar nova entidade com a chave primária da
entidade anterior e o atributo multivalorado.
 2FN
Uma relação R está na 2FN se, e somente se, ela
estiver na 1FN e todos os atributos que não fazem
parte da chave forem totalmente dependentes da
chave primária.

Procedimentos:
a) Identificar os atributos que não são
funcionalmente dependentes de toda a chave primária;
b) Remover todos esses atributos identificados e criar
uma nova entidade com eles.
 3FN
Uma relação R está na 3FN se somente estiver na
2FN e todos os atributos não chave forem
dependentes não transitivos da chave primária.

 cada atributo é funcionalmente dependente

apenas dos atributos componentes da chave primária
ou todos os seus atributos não chave são
independentes entre si.
 3FN - continuação
Procedimentos:
a) Identificar todos os atributos que são
funcionalmente dependentes de outros atributos não
chave;
b) Removê-los e criar uma nova entidade com os
mesmos.
Outras Formas Normais

- Boyce – Codd
- 4FN
- 5FN
 Workshop

Modelar Minimundo Proposto

Mapear Conceitualmente
Objetos do banco de dados

Tabela: unidade básica de armazenamento

Visão: subconjunto lógico de dados
Seqüência: gerador automático de números seqüenciais
Índice: estrutura em árvore B, B+, Mapa de bits, ...
Sinônimo: nomes alternativos de objetos
Usuários do banco de dados
Administrador de Banco de Dados (ABD)
Projetista de banco de dados
Analista de Sistemas
Programador
Usuários Finais
Casuais
Paramétricos
Sofisticados
 Criação de Usuários
CREATE USER usu01
IDENTIFIED BY senha01
DEFAULT TABLESPACE tools
TEMPORARY TABLESPACE temp
QUOTA unlimited ON tools
QUOTA 10M ON oradad
/
 Permissão de Usuários
Comandos: Grant e Revoke
Permissões:
create session;
create table;
create procedure;
select, insert, update, delete;
references, ...
 Tabela - nomenclatura
- deve começar com uma letra;
- pode ter de 1 a 30 caracteres;
- só aceita os caracteres: A..Z, a..z, 0..9, $, e #;
- não permite duplicação de nome para mesmo dono;
- não pode ser uma palavra reservada
 Tabela
CREATE TABLE
CREATE [GLOBAL TEMPORARY] TABLE [esquema.]tabela (
nome_atrib tp_dado_atrib [DEFAULT] expressão [,...] );

Estrutura da tabela

SQL> DESCRIBE dept

Name Null? Type
--------------------- -------- -----------------
id_dept NUMBER(2)
nome_dept VARCHAR2(14)
LOC VARCHAR2(13)
 Usuário x Esquema
Um esquema é um conjunto de objetos.
Os objetos de um esquema incluem tabelas, visões,
sinônimos, seqüências, procedimentos e funções
armazenados, índices, clusters, etc.
Esquema é subconjunto do banco de dados.

Usuários podem ter acesso a objetos do esquema.

No Oracle, o Esquema é um usuário com permissão

para criar os objetos do esquema.
 Dicionário de dados
- Contém o metadado
- Geralmente, acessamos suas visões
- Inclui entre outras informações:
o nome dos usuários ORACLE;
os direitos e privilégios que eles possuem;
nomes e estrutura de tabelas, visões, índices,
sinônimos, seqüências,...;
restrições aplicadas para uma tabela;
informações de auditoria para o administrador do
banco de dados.
 Tipos de visões do DD

USER_xxx  Objetos de propriedade do usuário.

ALL_xxx  Informação sobre todas as tabelas (de
objeto e relacionais) acessíveis ao usuário.
DBA_xxx  Para usuários com privilégio de DBA ou
acesso ao catálogo.
V$_xxx  Contém informações sobre as visões de
desempenho dinâmico, desempenho do servidor de
banco de dados e bloqueio.
 Visões que descrevem o DD

DICTIONARY
Lista o significado de todas as tabelas do
Dicionário de Dados, visões, sinônimos.
DICT_COLUMNS
Mostra a informação de todos os atributos que
podem ser acessados pelo usuário.
 Algumas visões do DD
USER_TABLES;
USER_TAB_COLUMNS;
USER_INDEXES;
USER_IND_COLUMNS;
USER_OBJECTS;
USER_CATALOG;
USER_CONSTRAINTS;
USER_CONS_COLUMNS.
 Restrições

- Garantir regras em nível de tabela.

Sempre que uma linha é inserida, alterada ou excluída
dessa tabela, a restrição deve ser satisfeita para ser
bem sucedida;
- Prevenir exclusões de uma tabela se houver dependências;
- Garantir parte das regras de negócio.
 Restrições de integridade

Not Null (Não Nulo)  Especifica que a coluna

(atributo) não pode conter valores nulos.
Unique  Especifica uma coluna ou um conjunto de
colunas que devem possuir valor único em toda a
tabela. Trata-se de uma chave candidata.
Primary Key  Atributo(s) único que identifica uma
linha da tabela. Trata-se da chave primária.
 Restrições de integridade

Foreign Key  Estabelece e garante um

relacionamento de chave estrangeira entre a(s)
coluna da tabela e a(s) coluna(s) da tabela
referenciada.
Check  Estabelece uma condição que deve ser
verdadeira para o atributo.
 Nível da Restrição

Nível de coluna: Faz referência a uma coluna em particular

e, em sua definição, inclui a coluna a que está
especificada. Qualquer tipo de restrição pode ser definida
em nível de coluna.
Nível de tabela: Faz referência a uma ou mais colunas e é
definida separadamente da definição das colunas da
tabela. Qualquer restrição, exceto NOT NULL, pode ser
definida em nível de tabela.
 Restrição Sintaxe
Nível de coluna:
coluna [CONSTRAINT nome_restricao] tipo_restricao,

Nível de tabela:
coluna,
[CONSTRAINT nome_restricao] tipo_restricao
(coluna, ...),
 Restrição Sintaxe Geral

CREATE TABLE [esquema.]tabela

(nome_coluna tipo_coluna [DEFAULT expr]
[column_constraint],
...
[table_constraint] [,...]);
 Restrição de NÃO NULO
CREATE TABLE namorada ...
telefone VARCHAR2(15) NOT NULL, ...
 
ou
 
CREATE TABLE namorada ...
telefone VARCHAR2(15)
CONSTRAINT namorada_telefone_nn NOT NULL,
...
 Restrição CHAVE
CANDIDATA
CREATE TABLE namorada ...
CPF VARCHAR2(11)
CONSTRAINT namorada_cpf_uk UNIQUE, ...
 Restrição de CHAVE
PRIMÁRIA
CREATE TABLE namorada ...
ID NUMBER(12)
CONSTRAINT namorada_pk PRIMARY KEY, ...
 Restrição CHAVE
ESTRANGEIRA
CREATE TABLE namorada ...
id_bairro NUMBER(12)
CONSTRAINT namorada_bairro_fk
REFERENCES bairro(id), ...
 Restrição de CHEQUE ou
VERIFICAÇÃO
Não podem ser utilizadas para definição de
restrições de cheque:
referências as pseudo-colunas CURRVAL,
NEXTVAL, LEVEL ou ROWNUM;
 chamada às funções SYSDATE, UID, USER ou
USERENV;
 consultas que fazem referência a valores em
outras linhas da tabela.
 Restrição de CHEQUE ou
VERIFICAÇÃO
CREATE TABLE namorada ...
nome NUMBER(12) NOT NULL,
idade NUMBER(2)
CONSTRAINT namorada_idade_ck
CHECK (idade IN (18, 19, 20, 21, 22, 23,
24, 25)), ...
 Tipos de dados do Oracle

CHAR(tamanho)
Dados do tipo caracter (letras maiúsculas ou
minúsculas, números e caracteres especiais (*,&,%,
$,etc.)) com comprimento fixo de bytes.
O tamanho é o comprimento máximo e não pode
ser maior que 2000. O tamanho padrão e mínimo é
1.
 Tipos de dados do Oracle

VARCHAR2(tamanho)
Dados caracter de comprimento variável (um
tamanho máximo deve ser especificado). O
tamanho mínimo e padrão é 1; o tamanho máximo
possível no Oracle 8i ou superior é 4000 (No Oracle
7.x o valor máximo de tamanho era 2000).
 Tipos de dados do Oracle
NUMBER(p,e)
p = precisão
e = escala
Dados numéricos de comprimento variável. Este
número contém precisão p e escala e (A precisão é
o número de dígitos decimais e a escala é o
número de dígitos a direita do ponto decimal). A
precisão pode variar de 1 a 38 e a escala de -84 a
127. Se a precisão não for especificada, será
assumida como 38.
 Tipos de dados do Oracle

DATE
Valor de data e hora entre 1° de janeiro de 4712
antes de Cristo e 31 de dezembro de 9999 depois
de Cristo.
 Tipos de dados do Oracle
CLOB
Dados caracter de um byte até 4 gigabytes.
BLOB
Dados binários (figuras, vídeos, etc) de até 4
gigabytes.
BFILE
Dados binários de até 4 gigabytes armazenados em
um arquivo externo do S.O.
 Tipos de dados do Oracle
Não usar!!!

*RAW(tamanho)
 
Dados binários brutos com “tamanho” de
comprimento máximo (um tamanho máximo deve
ser especificado. O valor máximo permitido para
tamanho é 2000).
 Tipos de dados do Oracle
Não usar!!!
*LONG RAW
Dados binários brutos de comprimento variável de
até 2 gigabytes
*LONG
Similar ao CHAR, mas o valor deve ser maior que
65535 caracteres. Não mais que uma coluna LONG
deve ser especificada em uma tabela.
 ALTER TABLE
ALTER TABLE tabela
ADD (coluna tipo_de_dado [DEFAULT expr]
[, coluna tipo_de_dado [DEFAULT
expr]] ...);
 
ALTER TABLE tabela
MODIFY (coluna tipo_de_dado [DEFAULT expr]
[, coluna tipo_de_dado [DEFAULT
expr]] ...);
 Drop Table

todos os dados e a estrutura serão excluídos;

todas as transações pendentes sofrerão 'commit';
todos os índices serão eliminados ;
não há como recuperar a tabela depois de eliminada (não
há 'rollback').
 Renomeando Objetos

RENAME DEPT TO DEPARTAMENTO;

 Comentários no Oracle
Adicionar comentário à tabela Emp:
COMMENT ON TABLE EMP IS 'Tabela de
Empresas';

O comentário pode conter até 2000 bytes de

comentário.

Para eliminar o comentário, devemos defini-lo como

vazio (''). Veja o exemplo abaixo:
  COMMENT ON TABLE EMP IS '';
 Consultando os
Comentários
Os comentários podem ser exibidos através de consultas
às visões do dicionário de dados:
ALL_COL_COMMENTS
USER_COL_COMMENTS
ALL_TAB_COMMENTS
USER_TAB_COMMENTS
 Seqüências
CREATE SEQUENCE seq_nome
[INCREMENT BY n]
[START WITH n]
[{MAXVALUE n | NOMAXVALUE}]
[{MINVALUE n | NOMINVALUE}]
[{CYCLE | NOCYCLE}]
[{CACHE n | NOCACHE}]
 Seqüências
Valores padrão:
INCREMENT BY = 1
START WITH = 1
CACHE = 20
NEXTVAL = próximo valor / CURRVAL = valor
corrente da seqüência.

USER_SEQUENCES e USER_OBJECTS 
informações das seqüências.
 Visões

Restringe o acesso, pois a visão pode mostrar apenas uma parte dos
dados armazenados;
Permite aos usuários fazer consultas simples para recuperar dados
de consultas complexas;
Dá independência a usuários ad hoc.
 Visões - Sintaxe
CREATE [OR REPLACE] [FORCE | NOFORCE]
VIEW nome_visao
[(alias, alias,...)]
AS subconsulta
[WITH CHECK OPTION [CONSTRAINT restricao]]
[WITH READ ONLY]
 Índices
Quando criar um índice
 O atributo aparece com freqüência na cláusula WHERE das
consultas ou em condições de junção (join);
 O atributo possui um intervalo grande de valores (muitos
valores distintos);
 Muitas linhas da tabela possuem valor nulo para o atributo;
 Dois ou mais atributos aparecem juntos na cláusula WHERE
das consultas ou em condições de junção com muita
freqüência;
 A tabela é muito grande e a maior parte das consultas
retorna até 4% de suas linhas.
 Índices
- Defina índices únicos como chave candidata;
- Nem sempre acrescentar um índice significará ganho
de desempenho;
- Tipos: Árvores B e B+; bitmap; IOT; etc.
 Índices
Quando não criar um índice:
 
 A tabela é pequena;
O atributo não é usado com freqüência nas
condições de consulta;
 A maior parte das consultas sobre a tabela
retornarão mais que 4% de suas linhas;
 A tabela sofre muita atualização.
 Índices - Sintaxe

CREATE [BITMAP] INDEX [ESQUEMA.] nome_indice

ON [ESQUEMA.] nome_tabela
(atributo [ASC | DESC] [ , atributo [ASC
| DESC] ] ...)
TABLEAPACE nome_tablespace
 DROP

DROP TABLE namorada;

DROP SEQUENCE seq_namorada;
 Consulta básica
SELECT [DISTINCT] {*, atributo [alias], ...}
FROM tabela;

SELECT – seleciona lista ou atributo para informação;

DISTINCT – elimina linhas duplicadas;
* – seleciona todos os atributos;
atributo – seleciona atributo com informação;
alias – dá um apelido para o atributo selecionado;
FROM tabela – especifica a tabela de onde será
retirada a informação.
 Expressões aritméticas e Concatenação

Expressões aritméticas
  +, -, * , /  

Concatenação
|| para concatenar valores do tipo caracter.
Valores literais envolvidos por plics (‘ ’).
 Funções
NVL(expr1, expr2)
troca os valores de expr1 por expr2 sempre que
o valor de expr1 for nulo.
 
LOWER(expr1)
converte os caracteres de expr1 em minúsculas.
 
 Funções
UPPER(expr1)
converte os caracteres de expr1 em maiúsculas.
 
SUBSTR(expr1, m[, n])
retorna os n primeiros caracteres de expr1
iniciando a contagem da m-ésima posição. Se m for
negativo, a contagem parte do final de expr1.
 Funções
LENGTH(expr1)
retorna o valor do número de caracteres de
expr1.
 
ROUND(expr1, n)
arredonda o valor de expr1 com n casas
decimais. Se n é omitido, arredonda sem casas
decimais. Se n for negativo, arredonda à esquerda do
ponto decimal.
 Funções

TRUNC(expr1, n)
trunca o valor de expr1 com n casas decimais.
Se n é omitido, trunca sem casas decimais. Se n for
negativo, trunca os algarismos à esquerda do ponto
decimal para zero.
 
MOD(m, n)
retorna o resto da divisão de m por n.
 Funções

TO_CHAR(numero|data, [formato])
converte o numero ou a data para caracter com
o formato especificado.
 
TO_NUMBER(caracter)
converte a string de caracteres contendo
apenas dígitos em valor numérico.
 Funções

TO_DATE(caracter, [formato])
converte a string de caracteres que representa
uma data em um valor data de acordo com o formado
especificado. Se a formatação é omitida, o formato
padrão será ‘DD-MON-YY’.
 Funções de Grupo

AVG(DISTINCT | ALL | n)
valor médio de n, ignorando os valores nulos.
 
COUNT(DISTINCT | ALL | expr1 | *)
retorna o número de linhas. O * conta todas as
linhas, inclusive as duplicadas e as que possuem
valores nulos.
 Funções de Grupo
MAX(DISTINCT | ALL | expr)
retorna o valor máximo de expr.
 
MIN(DISTINCT | ALL | expr)
retorna o menor valor de expr.
 
STDDEV(DISTINCT | ALL | n)
retorna o desvio padrão de n, sem considerar
os valores nulos.
 Funções de Grupo

SUM(DISTINCT | ALL | n)
soma os valores de n, ignorando os valores
nulos.
 
VARIANCE(DISTINCT | ALL | n)
retorna a variancia de n, ignorando os valores
nulos.
 Comparadores Lógicos

Os operadores = (igual), > (maior), < (menor),

>= (maior ou igual), <= (menor ou igual) e != ou
<> (diferente) podem ser usados para comparações
lógicas.
Para selecionar valores entre ‘a’ e ‘b’, devemos
utilizar o operador “ BETWEEN ‘a’ AND ‘b’ ”.
 Comparadores Lógicos

Para selecionar uma lista, usamos o operador

“IN(lista)”.
Comparações com valores nulos devem ser
feiras com o operador “IS NULL”.
Os operadores lógicos AND, OR e NOT também
estão disponíveis.
 Ordenação

SELECT expr
FROM tab
[ORDER BY {atributo|expressao} [ASC|
DESC] ];
 Limitando as linhas
selecionadas
SELECT expr
FROM tab
WHERE condição
[ORDER BY expr];
 LIKE

  O operador LIKE pode ser usado na condição da

cláusula WHERE, com os seguintes “coringas”:
  ‘%’ representa uma seqüência de zero ou
mais caracteres;
‘_’ representa um único caracter.
 Junção

Equijoin: relacionamento direto entre as tabelas;

Sintaxe:

SELECT tabela1.coluna, tabela2.coluna

FROM tabela1, tabela2
WHERE tabela1.coluna1 = tabela2.coluna2;
 Junção
Outerjoin: representado pelo sinal (+) colocado ao
lado do atributo que não satisfaz a condição. Esta
operação mostra as linhas que não satisfazem a
condição com valores nulos.
Sintaxe:

SELECT tabela1.coluna, tabela2.coluna

FROM tabela1, tabela2
WHERE tabela1.coluna1(+) = tabela2.coluna2;
 Junção
Non-Equijoin: quando não a(s) coluna(s) de uma
tabela não correspondem diretamente à(s) da outra
tabela, ou seja, não existe um relacionamento direto
entre as tabelas.
Sintaxe:

SELECT tabela1.coluna, tabela2.coluna

FROM tabela1, tabela2
WHERE <condição sem o operador ‘=’ >;
 Junção
Non-Equijoin - Exemplo:
SELECT e.nome, e.cargo, e.sal, s.grau
FROM empregado e, grau_salarial s
WHERE e.sal BETWEEN s.sal_minimo AND s.sal_maximo;
NOME CARGO SAL GRAU
------- ---------- ------- -------
JOAO GERENTE 5000 1
ALEX COZINHEIRO 1200 4
MARIA GARÇON 450 8
JOSE GARÇON 420 8
 Junção
Selfjoin: junção de linha de uma tabela com linhas da
mesma tabela.

Sintaxe:

SELECT PAPEL_A.coluna, PAPEL_B.coluna

FROM tabela1 PAPEL_A, tabela1 PAPEL_B
WHERE PAPEL_A.coluna1 = PAPEL_B.coluna2;
 Junção
Selfjoin - Exemplo:
SELECT empr.nome ||
‘ trabalha para ’ ||
gerente.nome
FROM empregado empr, empregado gerente
WHERE empr.id_gerente = gerente.id;

Resultado:
ALEX trabalha para JOAO
MARIA trabalha para JOAO
JOSE trabalha para JOAO
 Junção

Omissão da
cláusula WHERE  produto cartesiano
 Deve-se evitar esta operação.

Apelidos nas tabelas aumenta a performance das

consultas.
 Grupamentos

SELECT coluna, função_grupo

FROM tabela
[WHERE condição]
[GROUP BY expressão_de_grupo]
[HAVING condição_do_grupo]
[ORDER BY coluna];
 Subconsultas

A subconsulta é uma consulta que está envolvida por

outro comando SQL. Podemos encontrar uma
subconsulta nas cláusulas abaixo:
 
         WHERE;
 HAVING;
FROM de SELECT ou DELETE.
 Novas linhas às tabelas
Sintaxe:

INSERT INTO tabela [(coluna [, coluna ...])]

VALUES (valor [, valor ...])];
Ou
INSERT INTO tabela [(coluna [, coluna ...])]
subconsulta;
 Alterando os dados

Sintaxe:
 
UPDATE tabela
SET coluna = valor [, coluna = valor]
WHERE condição;
Excluindo linhas das tabelas
DELETE  para excluir todas as linhas da tabela
Sintaxe:
  DELETE FROM tabela;
   irá excluir linhas da condição
  Sintaxe:
  DELETE FROM tabela
WHERE condição;
Excluindo linhas das tabelas
TRUNCATE

todas as linhas da tabela serão removidas;

o espaço de armazenamento usado por esta tabela é
liberado;
não poderá fazer 'rollback' da remoção das linhas.

TRUNCATE TABLE nome_tabela;

 Transações
Temos uma transação ao executar:
- DML que efetuou alteração consistente de dados;
- comando DDL;
- comando DCL.

Termina com:
- COMMIT ou ROLLBACK;
- DDL ou DCL (commit implícito);
- Erro, EXIT ou Crash do sistema.
 Bloco PL/SQL
DECLARE (opcional)
         variáveis e constantes,
-          cursores,
-          expressões definidas pelo usuário.
BEGIN (obrigatório)
        comandos SQL,
-          estruturas de controle PL/SQL.
EXCEPTION (opcional)
        ações a tomar quando ocorrer uma exceção.
END; (obrigatório)
 Estruturas de Controle

- IF
- LOOP
- FOR
- WHILE
 Cursores
- Cursores explícitos
  DECLARE
CURSOR nome_cursor IS
comando_select;
 - Cursores explícitos com parâmetros
 DECLARE
CURSOR nome_cursor
[(parâmetro tipo_dado, ...)] IS
comando_select;
 Cursores
- Cursores “for update”
 DECLARE
CURSOR nome_cursor IS
SELECT ... FROM ... FOR UPDATE
[OF referencia_coluna] [NOWAIT];
 
 Cursores
- Percorrendo cursores
 
Sintaxe:
 
FOR nome_registro IN nome_cursor LOOP
comando1;
comando2;
...
END LOOP;  
 Funções
Sintaxe:
 
FUNCTION nome_função
[(parâmetro, ...)] RETURN tipo_dado
IS
BLOCO pl/sql;
 Procedimentos
Sintaxe:
PROCEDURE nome_procedimento [(parâmetro, ...)]
IS
BLOCO pl/sql;
 
Sintaxe do parâmetro:
 nome_parâmetro [IN | OUT | IN OUT ] tipo_dado
[{:= | DEFAULT} expr]
 Controlando exceções
EXCEPTION
WHEN exceção1 [OR exceção2 ...] THEN
comando1;
comando2;
...
[WHEN exceção1 [OR exceção2 ...] THEN
comando1;
comando2;
...]
[WHEN exceção1 [OR exceção2 ...] THEN
comando1;
comando2;
...]
 Principais exceções
NO_DATA_FOUND – consulta não retornou nenhuma
linha.
 
TOO_MANY_ROWS – consulta retornou mais de uma
linha.
 
INVALID_CURSOR – ocorreu uma operação inválida
sobre um cursor.
 Principais exceções
ZERO_DIVIDE – houve tentativa de divisão por 0.
 
DUP_VAL_ON_INDEX – tentativa de inserção de valor
numa coluna ou conjunto de colunas cujo valor deve
ser único.
 
OTHERS – qualquer exceção que não tenha sido
explicitamente citada anteriormente será tratada
nesse bloco.
 Otimizando o acesso ao
Oracle
Dois caminhos de acesso:
Leitura seqüencial da tabela;
Leitura indireta através de um índice.
 Uso do ROWID

Uso não recomendável  este endereço pode mudar

O formato do RowId varia de uma versão para outra

Exemplos:
a) alterando o nome do empregado
b) Excluindo registros duplicados
 O otimizador
- caminho segundo estratégia de menor custo
- melhor caminho de acesso leva em consideração:
Colunas mencionadas da cláusula where;
Que colunas são índices,
Que colunas estão definidas como NOT NULL,
Que índices podem ser usados.
 Regras de Utilização de
Índices
- exemplo citado
Cláusula “WHERE” Pode ser usado? Obeservação
A, B, C SIM Usamos o índice completo
A, B SIM Usamos os dois primeiros atributos
A, C SIM Usamos apenas “A”
B, C NÃO Primeiro atributo não informado
A SIM Usamos apenas “A”
B NÃO Primeiro atributo não informado
C NÃO Primeiro atributo não informado
 Um índice pode ser percorrido se:

o índice existe;
a coluna índice for referenciada na cláusula 'where'.
a cláusula 'where' realiza uma operação de:
- Igualdade:
- Intervalo ilimitado:
- Intervalo limitado:
 A escolha do índice
- Índices únicos e não únicos: os índices únicos serão
favorecidos sobre os índices não únicos.

- Vários índices não únicos: os registros identificados

pelo caminho de acesso do índice condutor (o
primeiro nome na sentença SQL), será unido com
aquele identificado por outro índice. A meta é
identificar aqueles registros pertencentes a todos os
índices.
 Condições de não utilização
de Índices
- Por Funções ou Operadores Aritméticos
- Por Convenção de Dados
- Caso de colunas com valores NULL
- Predicados com condição DIFERENTE ("NOT EQUAL")
 SQL com "ORDER BY"
- “ORDER BY” aumenta a necessidade de recursos
- tabelas temporárias são necessárias para ordenação

Exemplo:
select d.nome_dept, d.id_dept
from dept d
where d.local = 'RJ'
order by d.nome_dept;
 Order by
Podemos evitar tabelas temporárias se existir um
índice sobre a coluna alvo do “ORDER BY”:
- Coluna do “ORDER BY” definida com “NOT NULL”;
- Coluna “ORDER BY” deve ser a coluna de um índice
simples ou as primeira coluna de um índice
concatenado;
- “ORDER BY” não contém expressões;
- Não deve haver qualquer cláusula “GROUP BY”,
“DISTINCT” ou “FOR UPDATE”;
- Devemos garantir que o índice utilizado é o que
incide sobre o atributo da cláusula “ORDER BY”.
 Order by via índice
- índice em NOME_DEPT:

select d.nome_dept
from dept d
order by d.nome_dept ;

select d.nome_dept, d.id_dept

from dept d
where d.local = 'RJ'
order by d.nome_dept;
 Order by via índice
- índice em NOME_DEPT:

select d.nome_dept,
d.local
from dept d
where d.nome_dept != 'RH'
order by d. nome_dept;
 Order by – índice não
prioritário
- índice sobre LOCAL existe
- o índice sobre nome_dept não será usado:

select d.nome_dept,
d.id_dept
from dept d
where d.local = 'RJ'
order by d.nome_dept;
 Funções de MAX ou MIN
Condições para uso de índice:
- MAX / MIN incide sobre atributo da lista de seleção;
- Lista de seleção não deve ter operador de adição ou
concatenação;
- Lista de seleção contém somente a ocorrência de
atributo como agrupamento de MAX ou MIN;
- Não há junção;
- Não há cláusula “WHERE” ou “GROUP BY”;
- Coluna alvo do MAX ou MIN é indexada.
 Funções de MAX ou MIN

- SQL utilizará o índice sobre atributo SALARIO :

select (max(e.salario)*2) + 10000

from emp e;
Vários predicados de igualdade
com índice não único (Where)
-Índices não único sobre CARGO e ID_DEPT:

select e.nome_emp
from emp e
where e.cargo = 'GERENTE'
and e.id_dept = 20;
 Análise – Índice não único
1) O otimizador procura a primeira ou próxima
referência do índice sobre cargo (driving index)
contendo 'GERENTE';

2) Procura a primeira ou a próxima referência do

índice id_dept contendo valor 20;

3) Compara os ROWID's;
 Análise – Índice não único
4) Se forem iguais, registro encontrado e vai para a
próxima referência de (1) e compara com a próxima
referência de (2);

5) Se forem diferentes guarda a referência de (1) e

passa para a próxima referência de (2).

6) Continua a procura até que não exista mais

referências sobre o índice do atributo cargo (driving
index).
Predicado de igualdade + Predicado
sem limite + Índice não único
- índice sobre a igualdade será usado:
select e.nome_emp
from emp e
where e.CARGO = 'GERENTE'
and e.id_dept > 10;

- temos índices não únicos sobre cargo e id_dept;

- será utilizado o índice sobre cargo.
 Escolha do Otimizador
- Índice único e não único no mesmo comando:
 privilegia índice único!!!

select e.nome_emp
from emp e
where e.SALARIO = 3000
and e.id_emp = 7902;

- índice NÃO ÚNICO sobre “SALARIO”

- índice ÚNICO sobre “ID_EMP”
Vários índices no mesmo SQL
- índice único sobre “nome_emp” e “id_emp”
- índice não único sobre “salario”

select e.id_dept
from emp e
where e.salario = 3000
and e.nome_emp = 'JOAO'
and e.id_emp = 7602;

 o otimizador escolherá o índice sobre o atributo do

primeiro predicado informado na cláusula “WHERE”
 Cláusula OR
- O otimizador analisa como segue:
a) o caminho de execução é determinado como se a
cláusula OR e suas ramificações estivessem ausentes;
b) o caminho de execução é determinado para cada
ramificação da cláusula OR separadamente.

select e.nome_emp
from emp e
where e.id_dept = 10
and (e.SALARIO = 3000
or
e.CARGO = 'INF')
 OR - Situação I
- índice único em SALARIO / não único em CARGO:
Análise:
a) para o predicado id_dept = 10, haverá uma
pesquisa seqüencial completa da tabela;
b) para SALARIO = 3000, podemos percorrer - Índice
não único sobre SALARIO;
c) para CARGO = 'INF', podemos percorrer o índice
não único sobre CARGO.
 OR - Situação I
- índice único em SALARIO / não único em CARGO:
Conclusão:
O caminho de acesso identificado pelo predicado
“and (e.SALARIO = 3000 or e.CARGO = 'INF')” é
melhor do que o identificado por “e.id_dept = 10”.
O otimizador escolherá percorrer o caminho sobre os
índices da cláusula OR.
 OR - Situação II
- apenas índice não único sobre o atributo SALARIO:
Análise:
a) para o predicado id_dept = 10, haverá uma
pesquisa seqüencial completa da tabela;
b) para SALARIO = 3000, podemos percorrer o índice
não único sobre SALARIO;
c) para CARGO = 'INF', haverá uma pesquisa
seqüencial completa da tabela.
 OR - Situação II
- apenas índice não único sobre o atributo SALARIO:
Conclusão:
O caminho de acesso identificado pelo predicado
“and (e.SALARIO = 3000 or e.CARGO = 'INF')” não
poderá percorrer índice algum, pois o otimizador
exige que haja um índice para cada atributo
informado na cláusula “OR”.
Não há índice criado para “e.id_dept = 10”.
 Haverá uma leitura sequencial completa da tabela.
 Otimização de consultas

- Ressalte-se que todas as dicas são verdade na

maior parte das vezes.

- Todas elas podem não se tornar realidade

dependendo da situação ou de mudanças
implementadas nas novas versões do banco de
dados.

- Teste sempre sua implementação!

Sentenças SQL – Visão Geral

 ordem decrescente de performance:

- Junção;
- Subconsultas Correlacionadas;
- Subconsultas Não correlacionadas;
Sentenças SQL – Visão Geral

 ordem decrescente de desempenho:

- Junção;
- Subconsulta com cláusula “IN” ou “NOT IN”
- Subconsulta com cláusula “EXISTS” ou “NOT
EXISTS”;
- Consultas com “DISTINCT”.
 Subconsultas

- As subconsultas correlacionadas são muito

eficientes quando a coluna correlacionada da consulta
interna possui índice.

- As subconsultas não correlacionadas são mais

eficientes quando a consulta interna executa
rapidamente e retorna um conjunto pequeno de
valores.
 Subconsulta Correlata
- há um índice sobre o atribuito “id_emp”:
 
select e.id_emp, e.nome_emp
from emp e
where exists ( select *
from dept d
where d.id_emp = e.id_emp);
 Subconsulta NÃO Correlata
- subconsulta retornará poucas linhas de uma tabela
pequena :
select e.matricula_emp, e.nome_emp
from emp e
where matricula_emp in
(select g.matricula_emp
from gerente g
where d.dt_ini_ger >
add_months(sysdate, -2);
 Subconsultas

- Na Subconsulta não correlacionada, há uma

ordenação das linhas resultantes da consulta interna;

- Na Subconsulta correlacionada, o SGBD pode

manter uma tabela hash em memória. Esta tabela
contém as últimas linhas já verificadas;
 Subconsultas  Junção

- Sempre que possível, o SGBD transforma uma

subconsulta numa junção.

- Se alteramos nossa consulta para que no lugar da

subconsulta haja uma junção estamos minimizando o
tempo de execução de nosso comando;
 No lugar de:
select e.matricula_emp,
e.nome_emp,
e.id_emp
from emp e
where not exists
(select *
from dependente d
where e.id_emp = d.id_emp);
 Escreva:
select e.matricula_emp,
e.nome_emp,
e.id_emp
e.id_dept
from emp e,
dependente d
where e.id_emp = d.id_emp (+)
and d._id_emp is null;
 Parse

- Antes de o otimizador tentar verificar o melhor

caminho de acesso para o comando SQL, o SGBD
deve validar sintaticamente o comando. Esta fase é
chamada Parse (Interpretação em tempo de
execução).
 Minimizando o Parse
- Procure prefixar os atributos com o nome da tabela
ou seu apelido.
Não escreva:
select nome_emp,
nome_dept
from emp,
dept
where emp.id_dept = dept.id_dept
and SALARIO > 1000;
 Minimizando o Parse
Escreva:
select emp.nome_emp, dept.nome_dept
from emp, dept
where emp.id_dept = dept.id_dept
and emp.SALARIO > 1000;
 
ou
 
select e.nome_emp, d.nome_dept
from emp e, dept d
where e.id_dept = d.id_dept
and e.SALARIO > 1000;
 Minimizando o Parse
- Aproveite áreas de trabalho compartilhadas:
select *
from emp;
é diferente de :
SELECT * ou select *
FROM EMP; From Emp; 
ou ainda
select * from emp;
 Minimizando o Parse
Procure usar variáveis do tipo “BIND”:
- SGBD guarda os últimos comandos realizados em
memória, já analisados sintaticamente e com o
respectivo plano de acesso já definido.
- Expressões aritméticas podem ser calculadas no
programa e atribuídas a variáveis BIND. Estas, por
sua vez, seriam informadas no comando SQL.
- As operações de PARSE e OTIMIZAÇÃO são bastante
custosas para o SGBD.
 Variável BIND
Se executarmos a consulta abaixo: 
select e.nome_emp
from emp e
where id_emp = 10; 
e, logo a seguir, realizarmos a consulta:
select e.nome_emp
from emp e
where id_emp = 55;

 PARSE, OTIMIZAÇÃO e EXECUÇÃO nas duas

operações.
 Variável BIND
Primeira execução:

variavel_bind := 10;
--
select e.nome_emp
from emp e
where id_emp = :variavel_bind;

 temos PARSE, OTIMIZAÇÃO e EXECUÇÃO

 Variável BIND
Segunda execução:

variavel_bind := 55;
--
select e.nome_emp
from emp e
where id_emp = :variavel_bind;

 temos somente EXECUÇÃO.

Evite conversão implícita de
dados
Use:
select e.nome_emp
from emp e
where dt_admissao = to_date('19/12/1999',
'dd/mm/yyyy');
no lugar de:

select e.nome_emp
from emp e
where dt_admissao = '19-dec-99';
 Quando pensar em
otimização?
- modelo lógico;
- modelo físico;
- desenvolvimento;
- testes;
- implantação;
- produção;
- manutenção.
 Otimização

- Evite o uso de atributos que aceitam valores

nulos durante a modelagem de dados.
- Não esquecer que o diferente (“!=” ou “<>”)
em um predicado que será sempre tratado por
uma pesquisa seqüencial completa da tabela.
- Procure alterar a sentença SQL para facilitar o
trabalho do SGBD.
 Reescrita de SQL
- o índice sobre EMP(id_dept) não será usado:

select e.nome_emp
from emp e
where e.id_dept not in
(select d.id_dept
from dept d);
 Reescrita de SQL
- SQL que usa o índice com o mesmo resultado:

select e.nome_emp
from emp e, dept d
where e.id_dept = d.id_dept(+)
and d.id_dept is null;
 Reescrita de SQL
- 2° SQL que usa o índice c/ o mesmo resultado:

select e.nome_emp
from emp e
where e.id_dept in
(select e2.id_dept
from emp e2
minus
select d.id_dept
from dept d);
 UNION no lugar de muitos
AND ou OR

select e.id_emp
from emp e
where (e.id_dept = 10)
or (e.id_dept = 20 and e.SALARIO > 2500)
or (e.id_dept = 30 and e.SALARIO > 5000)
order by e.id_emp;
UNION no lugar de muitos
AND ou OR
select e.id_emp
from emp e
where e.id_dept = 10
union
select e.id_emp
from emp e
where e.id_dept = 20
and e.salario > 2500
union
select e.id_emp
from emp e
where e.id_dept = 30
and e.salario > 5000
order by 1;
 UNION no lugar de muitos
AND ou OR

- Cada passo usa o seu índice

- O UNION exclui as duplicidades (ALL para todas)

- Esta dica não é válida para comandos “UPDATE”

 EXISTS  DISTINCT
O comando:
select distinct e.id_dept, d.nome_dept
from dept d, emp e
where d.id_dept = e.id_dept;
deve ser alterado para:
select d.id_dept, d.nome_dept
from dept d
where exists (select 'x'
from emp e
where e.id_dept =
d.id_dept);
 Ordene com índices

- Tente fazer a eliminação de registros através de

predicados na cláusula WHERE.

- Desse modo, diminuímos o número de registros a

serem classificados na operação da cláusula ORDER
BY.
 Ordene com índices
No lugar de usar o comando:
select e.CARGO, avg(e.sal)
from emp e
group by e.CARGO
having e.CARGO !='PRESIDENTE'
and e.CARGO !='GERENTE';
Use o seguinte:
select e.CARGO, avg(e.sal)
from emp e
where e.CARGO !='PRESIDENTE'
and e.CARGO !='GERENTE'
group by e.CARGO;
 Dicas
- Lembre-se: se vários índices não únicos podem ser
utilizados, é recomendado que o predicado mais
restritivo seja especificado primeiro.
- O otimizador escolherá a última tabela da lista
‘from’ como tabela condutora, quando não estiver
claro o melhor caminho de acesso. Sempre colocar a
tabela que retorna menos registros por último.
- Sempre informe explicitamente os atributos das
cláusulas INSERT e SELECT.
 E se a tabela foi alterada?
Use sempre:

insert into
tab_exemplo (col1,col2,col3,...)
values (:vl1,:vl2,:vl3,...);

no lugar de:

insert into tab_exemplo

values (:vl1,:vl2,:vl3,...);
 Gatilhos (“triggers”)
Gatilhos são tipos especiais de procedimentos
armazenados. São ativados por eventos ocorridos no
SGBD como a execução de um comando DML em uma
tabela:
- Não poderemos chamar explicitamente um gatilho;
- Não poderemos passar parâmetro para um gatilho;
- Só podemos associar um gatilho a uma tabela *;
- Gatilho podem ser ativados por qualquer DML;
- O uso excessivo de gatilhos afeta a performance,
pois são interpretados em tempo de execução.