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.