You are on page 1of 19

Linguagem SQL

1. A linguagem SQL

SQL tem representado o padrão para linguagens de banco de
dados relacionais. Existem diversas versões de SQL. Essa
linguagem, originalmente chamada de SEQUEL, foi implementada
como parte do projeto do Sistema R, no início dos anos 70.
Inúmeros produtos são suporte atualmente para a linguagem
SQL.

A linguagem SQL tem diversas partes: linguagem de definição de
dados, linguagem interativa de manipulação de dados,
incorporação DML, definição de visões, autorização, integridade,
controle de transações.

2. Estruturas Básicas

A estrutura básica de uma expressão SQL consiste em três
cláusulas: select, from e where.

• A cláusula select corresponde à operação de projeção da
álgebra relacional. Ela é usada para relacionar atributos
desejados no resultado de uma consulta.
• A cláusula from corresponde à operação do produto
cartesiano da álgebra relacional. Associa ass relações que
serão pesquisadas durante a evolução de uma expressão.
• A cláusula where corresponde à seleção do predicado na
álgebra relacional. Ela consiste em um predicado envolvendo
atributos da relação que aparece na cláusula from.
O fato de o termo select possuir significado diferente em SQL e
na álgebra relacional é infelizmente histórico e precisa ser
diferenciada.

Uma consulta típica em SQL tem a seguinte forma:

Select A1, A2,...,An
From r1, r2,…,rm
Where P

Onde, cada Ai representa um atributo e cada ri, uma relação. P é
um predicado.
A consulta equivalente à seguinte expressão em álgebra
relacional seria:

π A1, A2, ...,An (σ P (r1 x r2 x...x rm))

Se a cláusula where for omitida, o predicado P é verdadeiro. No
entanto, diferente das expressões em álgebra relacional, em
SQL o resultado de uma consulta pode ter múltiplas cópias de
algumas tuplas.

3. A cláusula Select

O resultado de uma consulta SQL é naturalmente uma relação.
Consideremos uma consulta simples usando nosso exemplo de
banco. “encontre todos os nomes de todas as agências da relação
empréstimo”.

Select nome_agência
from empréstimo
O resultado é uma relação consistindo de um atributo simples
intitulado nome_agência.
Se desejarmos, por exemplo, eliminar a duplicidade de linhas,
podemos inserir a palavra-chave distinct depois de select.
Poderemos reescrever a consulta anterior da seguinte forma:

Select distinct nome_agência
from empréstimo

Ao contrário se quisermos deixar explícito que a duplicidade não
será eliminada, podemos usar a palavra-clave all.

Select all nome_agência
from empréstimo

O asterisco “*” pode denotar todos os atributos na cláusula
select.
Também poderá haver expressões aritméticas envolvendo os
operadores +, -, *, e /.
Por exemplo:

Select nome_agência, número_empréstimo, total * 100
from empréstimo

4. A cláusula Where

Considere a consulta: “encontre todos os números de
empréstimos feitos na agência Casa Forte, com totais
emprestados acima de 1.200 dólares”. Esta consulta pode ser
escrita como:
Select nome_empréstimo
From empréstimo
Where nome_agência=”Casa Forte” and Total > 1200

A SQL utiliza operadores lógicos and, or e not, na cláusula
where.
A SQL também possui o operador de comparação between para
simplificar a cláusula where que especifica que um valor pode ser
menor ou igual a algum valor e maior ou igual a algum outro valor.
Se desejarmos encontrar os números de empréstimos cujos
montantes estejam entre 90 e 100 mil dólares, podemos usar a
comparação between escrevendo:

Select nome_empréstimo
From empréstimo
Where total between 90000 and 1000000

Como também podemos usar a combinação de operadores: not
between.

5. A cláusula From

A cláusula from por si só define um produto cartesiano das
relações da cláusula. Para uma consulta: “para todos os clientes
que tenham empréstimo em um banco, encontre seus nomes e
números de empréstimos”, em SQL esta consulta pode ser
escrita como:

Select distinct nome_cliente,
devedor.número_empréstimo
From devedor, empréstimo
Where devedor.número_empréstimo =
empréstimo.número_empréstimo
6. Operação Rename

A SQL proporciona um mecanismo para dar novos nomes tanto
para relações como para atributos, usando a clausula as como segue:

nome_antigo as nome_novo

A clausula as pode ser usada tanto na clausula select como na
clausula from.

Select distinct nome_cliente,
devedor.número_empréstimo as id_emprestimo
From devedor, empréstimo
Where devedor.número_empréstimo =
empréstimo.número_empréstimo

Outro uso da cláusula as:

Select distinct nome_cliente,
T.número_empréstimo
From devedor as T, empréstimo as S
Where T.número_empréstimo =
S.número_empréstimo

Ou para comparação de tuplas da mesma relação. Suponha que
desejamos a seguinte consulta “encontre todos os nomes das
agencias que tenham fundos maiores que pelo menos uma agencia,
daquelas localizadas em João Pessoa”. A Consulta seria:

Select distinct T.nome_cliente
From agencia as T, agencia as S
Where T.fundos > S.fundos and
S.cidade_agencia = “João Pessoa”
7. Operações em Strings

As operações em strings mais usadas são as checagens para
verificação de coincidência de pares, usando o operador like.
Identificaremos esses pares por meio do uso de dois caracteres
especiais:

♦ Percentagem (%): o caracter % compara qualquer
substring
♦ Sublinhado (_): o caracter _ compara qualquer
caracter.

Comparações deste tipo são sensíveis ao tamanho da letra
(minúsculas <> maiúsculas).

Exemplo:

Select nome_cliente
From cliente
Where rua_cliente like
“%Desembargador%”

Para comparações que envolvam os próprios caracteres
especiais (% e _) utiliza-se o caracter de escape (\) imediatamente
antes do caracter especial que será comparado, para indicar que ele
deverá ser tratado como caracter normal.

Exemplo:

♦ Like “ab\%cd%”: corresponde a todos os strings que
comecem por “ab%cd”
♦ Like “ab\\cd%”: corresponde a todos os strings que
comecem por “ab\cd”

Também é permitido usar o not like que nos permite pesquisar
diferenças ao invés de coincidências.

8. Ordenação e Apresentação de Tuplas

SQL oferece ao usuário algum controle sobre a ordenação por
meio da qual as tuplas de uma relação serão apresentadas. A
cláusula order by faz com que as tuplas do resultado de uma
consulta apareçam em uma determinada ordem. Para listar em
ordem alfabética todos os clientes que tenham empréstimo na
agência Casa Forte, escrevemos:

Select distinct nome_cliente
from devedor, empréstimo
where devedor.numero_empréstimo =
empréstimo.número_empréstimo
and nome_agência = “Casa
Forte”
order by nome_cliente

Quanto ‘a forma de ordenação, podemos indicar desc para ordem
decrescente e asc para ordem ascendente. Se quisermos listar a
relação empréstimo inteira, por ordem descendente de total. Se
diversos empréstimo possírem o mesmo total, queremos que seja
realizada uma segunda ordenação ascendente por número de
empréstimo:
Select *
from empréstimo
order by total desc,
número_empréstimo asc

9. Definição de Esquema em SQL

9.1 Criando Tabelas

Para definir uma relação em SQL, utilizamos o comando create
table da seguinte forma:

Create table r (A1D1, A2D2,…,AnDn,
< regras de
integridade1>
...
<regras de
integridadek>)

onde r, é o nome da relação, cada Ai é o nome de um atributo no
esquema da relação r e Di é o tipo do domínio dos valores no
domínio dos atributos Ai. As regras de integridade permitidas
englobam:

Primary key (aj1, Aj2,…,Ajm)
Check (p)

A especificação da primary key diz que os atributos Aj1,
Aj2,…,Aj, formam a chave primária da relação. A especificação
de chave primária é opcional, mas desejável para cada uma das
relações. A cláusula check especifica um predicado que precisa
ser satisfeito por todas as tuplas em uma relação. Exemplos:

Create table cliente
(nome_cliente char(20) not null,
rua_cliente char(30),
cidade_cliente char(30),
primary key (nome_cliente))

Create table agência
(nome_agência char(15) not null,
cidade_agencia char(30),
fundos integer,
primary key (nome_agência),
check (fundos >=0))

Create table conta
(número_conta char(10) not null,
nome_conta char(15),
saldo integer,
primary key (número_conta)
check (saldo >= 0))

Create table depositante
(nome_cliente char(20) not null,
número_conta char(10) not null,
primary key (nome_cliente,
número_conta))
Para remoção de uma relação de um banco de dados SQL usamos
o comando drop table. O drop table remove todas as
informações de uma relação do banco de dados.

O comando
Drop table r

É uma opção mais drástica do que o comando

Delete from r

O comando alter table pode adicionar atributos em uma tabela
já existente. Neste caso, todas as tuplas já existentes, recebem
valor nulo para esse novo atributo. Exemplo:

Alter table r add A D

Para remover atributos de uma relação, o comando abaixo pode
ser usado:

Alter table r drop A

9.2 Visões

Definimos uma visão em SQL usando o comando create view.
Para definir a visão precisamos dar-lhe um nome e definir a
consulta que processará essa visão. A forma do comando create
view é a seguinte:

Create view v as <expressão_consulta>
Como exemplo, considere uma visão composta dos nomes das
agências e nomes de clientes que tenham uma conta na agência.
Definição:

Create view clientes_conta as
(select nome_agencia, nome_cliente
from depositante, conta
where depositante.número_conta =
conta.número_conta)

Usando agora a visão clientes_conta podemos encontrar todos os
cliente da agencia “ Casa Forte” , escrevendo:

Select nome_cliente
From clientes_conta
Where nome_agencia = ”Casa Forte”

A definição de create view cria uma definição de visão em um
banco de dados e essa definição fica armazenada no banco até
que um comando drop view nome_visão seja executado.

9.3 Modificações no banco de dados
a) Remoções

Um pedido para remoção de dados é expresso muitas vezes
do mesmo modo que uma consulta. Podemos remover
somente tuplas inteiras, não se pode excluir valores de um
atributo em particular. Em SQL, a remoção é expressa da
seguinte forma:

Delete from r
Where P
Onde P representa um predicado, e r uma relação. O
comando delete encontra primeiro todas as tuplas t em r
para as quais P(t) é verdadeira, e então, remove-as de r.
A cláusula where pode ser omitida no caso, da remoção de
todas as tuplas de r.

Exemplos:

Delete from depositante
Where nome_cliente = “Smith”

Delete from empréstimo
Where total between 1300 and 1500

Delete from conta
Where nome_agencia = “Piedade”

b) Inserções

Para inserir dados em uma relação podemos especificar
uma tupla a ser inserida ou escrever uma consulta cujo
resultado é um conjunto de tuplas a inserir. Um comando
insert simples é um pedido de inserção para uma tupla.

Exemplos:

Insert into conta
values (“Piedade”, “A-2903”, 1200)

Desta forma, vamos inserir valores nas tabelas cliente,
conta, agencia e depositante.
Na inserção de valores na tabela, é possível inserir valores
nulos em alguns atributos.

c) Atualizações

Em determinadas situações, podemos querer modificar
valores das tuplas sem, no entanto, alterar todos os
valores. Para esse fim, o comando update pode ser usado.
Exemplos:

Update conta
Set saldo = saldo * 1.05

Update conta
Set saldo = saldo * 1.06
Where saldo > 1000

Update conta
Set saldo = saldo * 1.05
Where saldo <= 1000

10. SQL avançado
10.1 Operações em conjunto

Como a união, a interseção e a diferença da álgebra
relacional, as relações participantes destas operações em
SQL precisam ser compatíveis, isto é, elas precisam ter o
mesmo conjunto de atributos.
Vamos dar exemplos dessas operações, usando dois
conjuntos básicos: (d) o conjunto de todos os clientes que
possuem uma conta no banco, e (b) o conjunto de todos os
clientes que contraíram empréstimo no banco.
Onde o conjunto (d) pode ser obtido com:

Select nome_cliente
From depositante

E o conjunto (b) pode ser obtido com:

Select nome_cliente
From depositante

a) União

Para encontrar todos os clientes do banco que
possuem empréstimos, um contam ou ambos,
escrevemos:

(Select nome_cliente
from depositante)
union
(select nome_cliente
from devedor)

A operação de union, ao contrário da cláusula select,
elimina automaticamente todas as repetições. Se não
quisermos que as repetições sejam eliminadas,
podemos escrever union all. Exemplo:

(select nome_cliente
from depositante)
union all
(select nome_cliente
from devedor)
b) Interseção

Para encontrar todos os clientes que tenham tanto
empréstimos quanto contas no banco, escrevemos:

(select distinct nome_cliente
from depositante)
intersect
(select distinct nome_cliente
from devedor)

A operação intersect elimina automaticamnete todas
as repetições.

Se desejarmos obter todas as repetições, teremos de
escrever intersect all, no lugar de intersect:

(select nome_cliente
from depositante)
intersect all
(select nome_cliente
from devedor)

c) Exceto

Para encontrar todos os clientes que tenham uma
conta e nenhum empréstimo no banco, escrevemos:

(select distinct nome_cliente
from depositante)
except
(select nome_cliente
from devedor)

Da mesma forma das operações anteriores, a
operação except elimina as tuplas repetidas, mas caso
deseje-se obtê-las, pode-se usar a except all.

10.2 Funções Agregadas

Funções agregadas são funções que tomam uma coleção de
valores como entrada, retornando um valor simples. A SQL
oferece cinco funções agregadas pré-programadas:

Média (average): avg
Mínimo (minimum): min
Máximo (maximum): max
Total (total): sum
Contagem (count): count

A entrada para sum e avg precisa ser um conjunto de
números, mas as outras operações podem operar com
conjuntos de tipos de dados não-numéricos tais como strings e
semelhantes.

Como exemplo de utilização, considere a consulta: “encontre a
média dos saldos nas contas de cada uma das agências do
banco”. Escrevemos a consulta:

Select avg (saldo)
From conta
Where nome_agencia = “casa forte”
Como resultado dessa consulta, obtemos uma relação com um
atributo único, contendo uma única linha com o valor numérico
que corresponde à média dos saldos na agência. Se quisermos
dar um nome a este atributo, pode-se usar a cláusula as.

Muitas vezes, em algumas circunstâncias, poderá haver
necessidade de aplicar uma função agregada a um grupo de
conjunto de tuplas. Neste caso podemos usar a cláusula group
by. Tuplas com os mesmos valores em todos os atributos
usados na cláusula group by são colocados em um mesmo grupo.

Como ilustração, considere a seguinte consulta: “encontre a
média dos saldos nas contas de cada uma das agências do
banco”. Escreve-se a seguinte consulta:

Select nome_agência, avg(saldo)
From conta
Group by (nome_agência)

Há casos em que existe a necessidade de eliminarem-se
repetições antes de efetuar uma função agregada. Se
realmente desejarmos eliminar repetições, usamos a palavra
distinct na expressão agregada.
Um exemplo dessa utilização, é a seguinte consulta: “encontre
todos os números dos depositantes de cada agência”. Neste
caso, um depositante é contado somente uma vez,
independente de quantos depósitos ele fez. Escrevemos essa
consulta da seguinte forma:

Select nome_agência, count(distinct nome_cliente)
From depositante, conta
Where depositante.número_conta =
conta.número_conta
Group by nome_agência

Às vezes precisamos definir condições e aplicá-las a grupos ao
invés de aplicá-las ao conjunto completo de tuplas. Podemos,
por exemplo, estar interessados em obter quais agências
possuem média dos saldos aplicados em conta maior que 1200
dólares. Essa condição então não seria aplicada a uma única
tupla, mas, em cada grupo determinado pela cláusula group by.
Nesse caso, utiliza-se a cláusula having do SQL. Exemplo:

Select nome_agência, avg(saldo)
From conta
Group by nome_agência
Having avg(saldo) > 1200

Se quisermos contar o número de tuplas em uma relação,
pode-se usar a notação: count(*), como por exemplo:

Select count(*)
From conta

Exercícios

1. Usando o Interbase, faça scripts em SQL para:

a. Criar de todas as tabelas de nosso banco de

dados fictício de agencia bancária: cliente,

agência, conta, depositante, e empréstimo.
b. Criar a visão, clientes_conta, como foi

especificada acima.

c. Especificar três tipos de consultas:

i. Usando as operações de conjuntos,

ii. Usando funções agregadas,

iii. Usando operadores having e/ou group by.