Linguagem SQL (com MySQL)

Redes de
Comunicação
Curso Proﬁssional de Técnico de Gestão e
Programação de Sistemas Informáticos
Ano lectivo 2009-2010 :: 11ºH

Escola Secundária de Adolfo Portela

Módulo VII (opção 1)
acesso a bases de dado remotas via web

Escola Secundária de Adolfo Portela Marco Pinheiro | profmarco550@gmail.com

1. introdução...
a) materiais de suporte
Livros de referência:

“Beginning MySQL”; Robert Sheldon, Geoff Moes;
Editora: Wrox; ISBN: 0764579509;

“SQL - Structured Query Language - 6ª Edição
Actualizada e Aumentada”; Luís Manuel Dias
Damas; Editora: FCA; ISBN: 972-722-443-1;

Webliograﬁa de referência:

http://www.hscripts.com/tutorials/mysql/index.php

http://www.estig.ipbeja.pt/~eidbd/sql.htm

http://www.w3schools.com/sql/default.asp


1. introdução...
b) introdução | SQL?!
SQL (do inglês Structured Query Language, ou Linguagem de Consulta
Estruturada), é uma linguagem de pesquisa, declarativa, para Bases de Dados
Relacionais;

Vamos aprender SQL para aceder e manipular dados no SGBDs MySQL, mas
esta linguagem é comum a outros SGBDs: SQL Server, Access, Oracle, DB2
entre outros...

O SQL foi desenvolvido originalmente no início dos anos 70 nos laboratórios da
IBM;

O SGBD que vamos utilizar nas aulas será o MySQL


1. introdução...
b) introdução | a consola
A consola (linha de comandos) do MySQL está localizada em mysqlbin e tem o
nome mysql.exe. Para ser iniciado como administrador, mysql -u root

Vai ser na consola que iremos executar todas as operações de SQL;

Nota: O comando será apenas executado quando a linha terminar com ; caso contrário,
sempre que for premida a tecla ENTER é efectuada apenas uma quebra de linha (-->)


1. introdução...
c) primeiros passos | show databases
Para termos acesso a uma lista de bases de dados existentes no servidor

show databases;


1. introdução...
c) primeiros passos | create database
Para criar uma nova base de dados

create database NomeDaNovaBaseDados;


1. introdução...
c) primeiros passos | use e show
Para utilizar uma base de dados da lista

use NomeDaBaseDados;

Para listar as tabelas da base de dados em uso

show tables;

Nota: no exemplo o resultado mostrado é
“Empty set” na medida em que ainda não foram
criadas quaisquer tabelas na dita base de
dados...


1. introdução...
c) primeiros passos | describe
Após criarmos uma tabela podemos visualizar a sua estrutura utilizando o
comando DESCRIBE ou simplesmente DESC seguido do nome da tabela,
ou o comando SHOW FIELDS FROM nomeTabela ;

DESC nomeTabela ; (show create table nomeTabela -> mais detalhe!)

SHOW FIELDS FROM nomeTabela ;


1. introdução...
d) tipos de dados aceites no SQL
Tipo Abreviação Descrição
INTEIRO INT ou Números inteiros. Existem outros tipos de números inteiros de acordo com o
INTEGER sgbd utilizado.

REAL DOUBLE ou Números reais. Permitem armazenar todo tipo de número não inteiro. Existem
REAL outros tipos de números reais de acordo com o sgbd utilizado.

Caracter. Permite a inclusão de dados alfanuméricos com tamanho pré-
CARACTER CHAR (x) definido. O número de caracteres é definido entre os parênteses. Ocupa
sempre o número indicado (com espaços...)

CARACTER Caracter. Permite a inclusão de dados alfanuméricos. O número de caracteres
VARIÁVEL VARCHAR (x) é definido entre os parênteses, porém o número de bytes utilizados pelo
campo é apenas o especificado (número).

DATA DATE Data. Existem diversos tipos de datas de acordo com o sgbd utilizado.

BOOLEANO BOOLEAN Armazena um bit de informação, utilizado para verdadeiro ou falso.


1. introdução...
d) tipos de dados aceites no MySQL
Para valores numérios inteiros temos:


1. introdução...
Para valores numérios reais temos:


1. introdução...
Para valores do tipo caracter (string) temos:


1. introdução...
Para valores tipo data temos:


DDL - Linguagem de Definição de Dados
DML - Linguagem de Manipulação de Dados


2. DDL - Linguagem de Definição de Dados
a) definição
Linguagem de definição de dados (ou DDL, de Data Definition Language) é
um conjunto de comandos dentro do SQL usada para a definição das
estruturas de dados, fornecendo as instruções que permitem a criação,
modificação e remoção das tabelas, assim como criação de índices (ou
chaves).

Estas instruções SQL permitem definir a estrutura de uma base de dados,
incluindo colunas (campos), tabelas, índices (chaves), etc.

Entre os principais comandos DDL estão CREATE (criar), ALTER (alterar)
e DROP (apagar).


a) cad - create, alter, drop
CREATE
Uma declaração CREATE permite a criação de uma nova base de dados, tabela, índice, ou
consulta armazenada. Entre os principais comandos incluidos estão CREATE DATABASE (criar
base de dados) e CREATE TABLE (criar tabela);

ALTER
Uma declaração ALTER permite alterar um objeto de um base de dados.
Entre os principais comandos estão ALTER TABLE ADD (adicionar uma coluna na tabela),
ALTER TABLE DROP (excluir uma coluna na tabela), entre outros...

DROP
Uma declaração DROP permite remover (destruir) uma base de dados existente, tabela ou
índice.
Entre os principais comandos incluídos estão o DROP DATABASE (eliminar uma base de
dados inteira), DROP TABLE (excluir tabela) entre outros...


a) cad - create, alter, drop

create table


b1) CREATE TABLE
CREATE TABLE é o comando para a criação de tabelas e deve ser seguido pelo nome que
queremos dar à tabela;

Dentro do comando, devemos deﬁnir os nomes dos campos de acordo com a conveniência
da base de dados, e determinar o tipo de dados que poderão ser incluídos nesse campo.

CREATE TABLE nomeTabela CREATE TABLE student
( (
fieldName1 dataType(size) , studID INT ,
fieldName2 dataType(size) name VARCHAR(30) ,
... address VARCHAR(40)
) [ ENGINE = engineUtilizada ] ; ) ENGINE = InnoDB ;

Tipos de "engine" da base de dados no SGBD MySQL:

ENGINE = {BDB | MEMORY | ISAM | INNODB | MERGE | MYISAM}


b1) CREATE TABLE | auto-increment
Se desejamos que o valor de um campo seja de auto-incremento (numeração automática
sequêncial) devemos inserir AUTO_INCREMENT na frente do campo pretendido;

Isto pode ser utilizado por exemplo, para automatizar um nº que sirva de chave primária na
tabela

CREATE TABLE student
(
studID INT PRIMARY KEY AUTO_INCREMENT ,
name VARCHAR(30) ,
address VARCHAR(40)
) ENGINE = InnoDB ;

Nota: cada tabela pode ter apenas UM CAMPO com AUTO_INCREMENT e o mesmo terá de
ser obrigatoriamente deﬁnido como chave primária ( PRIMARY KEY )!


b1) CREATE TABLE | default
Valor predefinido para um campo da tabela

(
studID INT,
name VARCHAR(30) ,
address VARCHAR(40) DEFAULT ‘ Aveiro ‘
) ENGINE = InnoDB ;


b2) CREATE TABLE | constraints

constraints


b2) create | constraints
Há diversas regras de “constraint” que podem ser aplicadas aos campos que formam uma
tabela.

A sua definição pode ser feita de duas formas: inline ou com a palavra constraint (com a
excepção do NOT NULL que pode apenas ser definida inline)

Eis as mais importantes:

NOT NULL (definido apenas inline)

UNIQUE

PRIMARY KEY

FOREIGN KEY

CHECK


b2) create | constraints: not null (nn)
O constrangimento NOT NULL força um campo a não aceitar valores NULL (vazios), ou seja,
obriga a que este seja sempre preenchido (tal como explicado anteriormente).

Eis um pequeno exemplo onde o constrangimento é deﬁnido inline:

(
studID INT NOT NULL ,
name VARCHAR(30) ,
address VARCHAR(40)
) ENGINE = InnoDB ;


b2) create | constraints: unique (un)
O constrangimento UNIQUE identiﬁca de forma única cada registo da tabela da base de
dados (não permite que o valor se repita).

Tem o mesmo efeito prático da PRIMARY KEY. inline:

CREATE TABLE student CREATE TABLE student
( (
studID INT , studID INT UNIQUE ,
name VARCHAR(30) , name VARCHAR(30) ,
address VARCHAR(40) , address VARCHAR(40)
CONSTRAINT un_nomeConstricao UNIQUE ( studID ) ) ENGINE = InnoDB ;
) ENGINE = InnoDB ;

Obs 1) O constrangimento PRIMARY KEY implementa automaticamente este UNIQUE;

Obs 2) Podemos ter vários campos com o constrangimento UNIQUE.

Nota: un_nomeConstricao é o nome do constraint. Tipicamente tem um preﬁxo (nn, un, pk,
fk,ck), seguido de underscore e o nome "simbólico" para a regra de constrangimento.

Nota2: O MySQL é case sensitive (sensível às maiúsculas) no nome do constraint!
nn_nomeConstricao e un_nomeconstricao seriam duas regras de constrangimento diferentes!


b2) create | constraints: primary key (pk)
O constrangimento PRIMARY KEY deﬁne a chave primária da tabela.

O valor introduzido não pode ser nem repetido nem nulo (implementa automaticamente os
constrangimentos UNIQUE e NOT NULL).
inline:

( (
studID INT AUTO_INCREMENT, studID INT PRIMARY KEY ,
address VARCHAR(40) , address VARCHAR(40)
CONSTRAINT pk_nomeConstricao PRIMARY KEY ( studID ) ) ENGINE = InnoDB ;
) ENGINE = InnoDB ;

O constrangimento PRIMARY KEY implementa automaticamente o UNIQUE.

Lembra-te: podemos ter vários campos com o constrangimento UNIQUE mas apenas UMA
PRIMARY KEY por tabela.


b2) create | constraints: primary key (pk)
(
studID INT UNSIGNED AUTO_INCREMENT ,
name VARCHAR(30) ,
address VARCHAR(40) ,

CONSTRAINT pk_nomeConstricao PRIMARY KEY ( studID )

);


b2) create | constraints: foreign key (fk)
A chave estrangeira (foreign key) é uma cláusula que deve ser incluída quando possuímos
duas tabelas relacionadas numa base de dados.

Através da chave estrangeira estabelecemos as relações entre duas ou mais tabelas.

A chave estrangeira desta forma referencía o campo que é chave primária na tabeça
relacionada.

(
studID INT PRIMARY KEY ,
name VARCHAR(30) ,

FOREIGN KEY ( campoChaveEstrangeira ) REFERENCES Nome_outraTabela ( Nome_da_Chave )

) ENGINE = InnoDB ;


b2) create | constraints: foreign key (fk)
Implementando a chave estrangeira através do método de CONSTRAINT:

(
name VARCHAR(30) ,
class INT ,

CONSTRAINT fk_nomeConstricao FOREIGN KEY ( CampoChaveEstrangeira )
REFERENCES Nome_outraTabela( Nome_da_Chave )

) ENGINE = InnoDB ;


b2) create | constraints: check (ck)
Validação dos valores introduzidos ( “regra de validação” )

Deve ser incluida em campos que estejam DEPOIS da chave primária.

Eis um exemplo para uma regra aplicada ao campo class que só aceita turmas com número
compreendido entre 1 e 10:
inline:

( (
studID INT PRIMARY KEY , studID INT PRIMARY KEY ,
address VARCHAR(40) , address VARCHAR(40) ,
class INT , class INT ,

CONSTRAINT ck_nomeConstricao CHECK CHECK ( class BETWEEN 0 AND 10 )
( class BETWEEN 0 AND 10 )
) ENGINE = InnoDB ;
) ENGINE = InnoDB ;


c) cad - create, alter, drop

alter table


c) ALTER TABLE
Após criarmos uma tabela podemos alterar sua estrutura com o uso da cláusula ALTER
TABLE. Lembra-te que esta alteração é sempre sobre a estrutura da tabela, e não sobre os
dados.

Esta alteração à tabela pode ser efectuada de duas formas:

ou acrescentando um novo campo (utilizando ADD)

ou alterando-se as propriedades de um campo já existente (utilizando-se CHANGE ou
MODIFY).

O comando ALTER TABLE tem a seguinte sintaxe (a excepção é para mudar nome a uma
tabela >> ALTER TABLE nomeActual RENAME novoNome):

ALTER TABLE Nome_Tabela
[ADD Nome_Campo Nova_Regra | nova_regra
MODIFY Nome_Campo NovoTipo ou Nova_Regra
CHANGE Nome_Campo_actual novo_Nome_Campo NovoTipo [e Nova_Regra]
DROP Nome_Campo | RegraConstraint
];


c1) ALTER TABLE | ADD
Podemos utilizar a cláusula ADD para adicionar um novo campo à tabela.

Para isso, além do nome, devemos deﬁnir também o seu tipo da mesma forma como fazemos
ao criar o campo numa nova tabela:

ADD nomeCampo TipoDados ;

ALTER TABLE Cliente
ADD Nome_Mae VARCHAR ( 60 ) ;

Caso desejemos que um campo seja inserido numa ordem especíﬁca ( INÍCIO ou DEPOIS de
um determinado campo ), utilizamos a seguinte sintaxe:

ALTER TABLE Cliente
ADD Nome_Mae VARCHAR ( 60 ) FIRST;

ALTER TABLE Cliente
ADD Nome_Mae VARCHAR ( 60 ) AFTER nomeCampo;


c1) ALTER TABLE | ADD
Com o ADD podemos adicionar também regras a um dado campo.

Na nossa tabela, se quisermos que o campo nome seja chave primária, podemos fazer:

ALTER TABLE Cliente
ADD PRIMARY KEY ( Nome ) ;

Se quisermos que o campo dataNascimento tenha valores entre 1980-12-31 e 2009-12-31,
podemos fazer:

ALTER TABLE Cliente
ADD CHECK ( nome LIKE ‘ a% ‘ ) ;

ou através da forma de declaração da regra de constrangimento via constraint:

ALTER TABLE Cliente
ADD CONSTRAINT ck_nomeConstricao CHECK ( class BETWEEN 0 AND 10 )

Podiamos inclusivamente adicionar uma chave estrangeira (foreign key):

ALTER TABLE Cliente
ADD FOREIGN KEY ( campoChaveEstrangeira )
REFERENCES Nome_outraTabela ( Nome_da_Chave )


c2) ALTER TABLE | MODIFY
Altera as especiﬁcações de um campo da tabela (tipo de dados, regras, etc) mas o
nome mantém-se.

Sintaxe:

ALTER TABLE nomeDaTabela MODIFY campo novoTipoDados NovaRegra;

Ex.

ALTER TABLE student
MODIFY stud_name VARCHAR ( 50 ) ;

ou mais complexo...

ALTER TABLE student
MODIFY stud_name VARCHAR ( 60 )
NOT NULL DEFAULT ‘ helder ’;


c3) ALTER TABLE | CHANGE
Altera o nome de um campo (coluna) e do respectivo tipo de dados (type) e as suas regras

Nota: quando se muda o nome a uma coluna com o CHANGE, somos obrigados a
especiﬁcar novamente o seu tipo de dados mesmo que este se mantenha (terá de ser
repetido).

Sintaxe:

ALTER TABLE nomeDaTabela
CHANGE nomeDoCampoActual
novoNome novoTipoDados
[ novas regras ] ;

Ex.

ALTER TABLE student
CHANGE name
numTelefone INT
NOT NULL UNIQUE ;


c4) ALTER TABLE | DROP
Se desejarmos ELIMINAR algo da estrutura da nossa tabela, utilizamos a seguinte sintaxe:

[DROP COLUMN nome_campo];
[DROP FOREIGN KEY fk_simbolo];
[DROP PRIMARY KEY];

Exemplos:

ALTER TABLE student DROP COLUMN stud_name ;

ou

ALTER TABLE student DROP FOREIGN KEY fk_simbolo ;

ou

ALTER TABLE student DROP PRIMARY KEY ;


d) cad - create, alter, drop

DROP TABLE


d) DROP TABLE
Se desejarmos ELIMINAR uma tabela intera da base de dados:

DROP TABLE nomeTabela;


Informação avulsa... :)
mysqldump e show create
Se desejarmos EXPORTAR toda a estrutura e o conteúdo de uma base de dados no
MySQL, devemos proceder da seguinte forma (convém criar um atalho para simpliﬁcar o
processo...)

mysqldump -u root nomeBaseDados > nomeFicheiro.sql

Caso tenham necessidade de ver a estrutura de uma tabela em detalhe, podem
utilizar:

show create table nomeTabela


3. DML - Linguagem de Manipulação de Dados
a) deﬁnição
Mostrar os campos (colunas) de uma tabela:

Os principais comandos DML são:

INSERT ( Inserção de Dados )

SELECT ( Seleção de Dados )

UPDATE ( Actualização de Dados )

DELETE ( Eliminação de Dados )



inserção de dados | INSERT


c) inserção de dados | INSERT
Vamos agora perceber como podemos introduzir novos registos numa tabela da nossa base
de dados. Caso se pretenda preencher todos os campos pela ordem definida na própria
estrutura da tabela, utilizamos a seguinte sintaxe:

INSERT INTO nomeTabela
VALUES ( valor_campo1 , ‘ valor_campo2 ‘ , ... ) ;

Caso haja necessidade de preencher apenas alguns campos, há a necessidade de
especificar quais são os campos e os respectivos valores. Já os campos omitidos ficam
com valor NULL.

INSERT INTO nomeTabela (campo1 , campo2 , ... )
VALUES ( valorNumerico1 , ' valorString1 ' , ... ) ;

ou então assim:

INSERT INTO nomeTabela
SET campo1 = valorNumerico1, campo2 = ‘ valorString1 ‘ , ... = ... ;

NOTA: strings e datas deverão ser delimitadas por aspas. Valores numéricos não
necessitam.


c) inserção de dados | INSERT | Exemp.
INSERT INTO Books
VALUES (12786, "Letters to a Young Poet", 1934),
(13331, "Winesburg, Ohio", 1919),
(14356, "Hell"s Angels", 1966),
(15729, "Black Elk Speaks", 1932),
(16284, "Noncomformity", 1996),
(17695, "A Confederacy of Dunces", 1980),
(19264, "Postcards", 1992),
(19354, "The Shipping News", 1993);

INSERT INTO AuthorBook
VALUES (1006, 14356), (1008, 15729), (1009,
12786), (1010, 17695),
(1011, 15729), (1012, 19264), (1012, 19354), (1014,
16284);

INSERT INTO Authors
VALUES (1006, "Hunter", "S.", "Thompson"),
(1007, "Joyce", "Carol", "Oates"),
(1008, "Black", NULL, "Elk"),
(1009, "Rainer", "Maria", "Rilke"),
(1010, "John", "Kennedy", "Toole"),
(1011, "John", "G.", "Neihardt"),
(1012, "Annie", NULL, "Proulx"),
(1013, "Alan", NULL, "Watts"),
(1014, "Nelson", NULL, "Algren");



consulta de dados | SELECT


d1) consulta de dados | SELECT
Depois de haver registos inseridos nas tabelas, temos de ser capazes de efectuar consultas
sobre eles. A sintaxe é a seguinte:

SELECT campo1, campo2, ... FROM nomedaTabela ;

Também aqui podemos utilizar o símbolo * para seleccionar TODOS os campos da tabela:

SELECT * FROM nomedaTabela ;


d3) consulta de dados | SELECT ORDER BY
Se houver a necessidade de ordenar os registos do resultado de uma consulta, tal pode ser
feito bastando para isso especiﬁcar quais os campos envolvidos, e qual a ordem a aplicar
em cada um deles - ascendente (ASC) ou descendente (DESC):

SELECT * FROM nomedaTabela ORDER BY nomeCampo [ ASC | DESC ] ;

Exemplos:
SELECT * FROM cds ORDER BY titel ASC ; SELECT * FROM cds ORDER BY id DESC ;


d3) consulta de dados | SELECT AS (alias)
Podemos ainda “mascarar” o nome verdadeiro de um campo da tabela utilizando a função
AS utilizando a seguinte sintaxe:

SELECT nomedoCampo1 AS novoNome, nomedoCampo2 AS novoNome2, ...
FROM nomedaTabela ;

Exemplo:
SELECT titel AS titulo, interpret AS artista, jahr AS dataPublic FROM cds;


d4) consulta de dados | critérios WHERE
Por vezes há a necessidade de introduzir cláusulas ou critérios na consulta. Utilizamos para
isso o WHERE:

SELECT * FROM nomedaTabela WHERE condição

Exemplo:
SELECT * FROM cds WHERE jahr = 2001 ;


d4) consulta de dados | critérios WHERE
Aqui temos um exemplo mais complexo (tem uma condição maior) mas que obedece às
mesmas regras de construção da anterior:

SELECT CDName, Category, InStock+OnOrder-Reserved AS Available
FROM CDs
WHERE ( Category = " Blues " OR Category = " Jazz " )
AND ( InStock+OnOrder-Reserved ) > 20 ;


d4) consulta de dados | WHERE ... LIKE
Quando os valores que utilizamos como critério não são exactos e sabemos apenas alguns
detalhes deles, podemos utilizar a palavra LIKE.

% representa diversos caracteres que desconhecemos;

_ (underscore) representa um caracter que desconhecemos;

SELECT campos FROM nomedaTabela WHERE nomeCampo [NOT LIKE | LIKE ] valor ;


Exemplos:

1) vamos procurar todos registos da tabela CDs cujo titulo comece com a letra g

SELECT * FROM CDs WHERE titel LIKE ‘ g% ‘ ;


Exemplos:

2) vamos agora procurar todos registos da tabela CDs cujo titulo não tenha apenas 5 letras
e cujo ano de lançamento (campo jahr) seja superior ao ano 2000

SELECT * FROM CDs WHERE titel NOT LIKE ‘_ _ _ _ _ ‘ AND jahr > 2000 ;


d4) consulta de dados | WHERE ... outros...
Além do LIKE existem ainda outros operadores que podem ser usados como critério na
utilização da cláusula WHERE:

BETWEEN / NOT BETWEEN

IS NULL / IS NOT NULL

Ex.
SELECT * FROM CDs WHERE jahr BETWEEN 2000 AND 2001 ;


d4) consulta de dados | WHERE | AND OR
Podemos ainda juntar diversos critérios com os operadores AND e OR:

Exemplo com o operador AND (E):

SELECT BookName , Category , InStock , OnOrder
FROM Books
WHERE Category= ’ Fiction ’ AND ( InStock+OnOrder ) > 40
ORDER BY BookName;

Exemplo com o operador OR (OU) e o símbolo diferente ( < > )

SELECT BookName , Category , InStock , OnOrder
FROM Books
WHERE InStock > 30 OR OnOrder < > 60
ORDER BY BookName;


d2) consulta de dados | SELECT LIMIT
Caso o resultado da consulta tenha demasiados registos, o programador poderá especiﬁcar
um limite máximo:

SELECT campo1, campo2, ... FROM nomedaTabela LIMIT numeroMáximo ;

Caso não queiramos começar a consulta a partir do primeiro registo mas avançar X registos
(ideal quando se quer dividir o resultado por páginas), utilizamos a seguinte estrutura:

SELECT campo1, campo2, ... FROM nomedaTabela LIMIT offset , numeroMáximo ; ou
SELECT campo1, campo2, ... FROM nomedaTabela LIMIT numeroMáximo
OFFSET numeroRegInicial ;

Exemplos implementados das duas formas mas com o mesmo resultado ﬁnal:
SELECT * FROM student LIMIT 5 , 10 || SELECT * FROM student LIMIT 10 OFFSET 5

No exemplo, a consulta vai mostrar no máximo 10 registos, e começa a contar a partir do
5º registo da tabela em diante. Ou seja, se todos os registos tivessem um campo idStudent
com números de 1 a 100... mostraria os alunos onde idStudent fosse entre 6 e 15.


e) consulta de dados | COUNT
Por vezes há a necessidade de contar registos. Nesses casos utiliza-se a função COUNT.

Exemplo:

SELECT count ( * ) FROM cds;


f) consulta de dados | GROUP BY
Podemos agrupar dados utilizando a cláusula GROUP BY que permite unir numa única linha
todas as linhas selecionadas que possuem os mesmos valores.

Exemplo: aqui vão ser agrupados os registos cujo intérprete se repita

SELECT interpret , count ( interpret ) FROM cds GROUP BY interpret;


g) consulta de dados | DISTINCT
Por vezes há necessidade de ignorar registos com valores duplicados.
Nesses casos podemos utilizar a função DISTINCT.

SELECT DISTINCT nomeCampo FROM nomeTabela;


h) consulta de dados | FUNCTIONS
Os SGBDs actuais suportam diversas funções de cálculo estatístico simples como:

Ex. de utilização:

SELECT
SUM (Amount) AS SumOfAmount
COUNT (Amount) AS CountOfAmount
AVG (Amount) AS AvgOfAmount
MIN (Amount) AS MinOfAmount
MAX (Amount) AS MaxOfAmount
FROM SALES;

Resultado do exemplo apresentado:



actualização de dados | UPDATE


i) actualização de dados | UPDATE
O comando UPDATE serve então para efectuar uma actualização a um registo e pode ser
realizado sem a cláusula WHERE.

No entanto, é a cláusula WHERE que vai deﬁnir exactamente qual/quais é/serão os registos a
serem ACTUALIZADOS. Caso seja omitido, TODOS OS REGISTOS SERÃO
ACTUALIZADOS POR IGUAL!!

Sintaxe de utilização:

UPDATE nomeTabela SET
nomeColuna1=valor1 [, nomeColuna2=valor2 ...]
[WHERE condição];


Exemplo:

Vamos alterar o nome do intérprete Groove Armada por Groovy em todos os registos da tabela CDs.

UPDATE cds SET interpret = ' Groovy ' WHERE interpret = ' Groove Armada ' ;


Outros exemplos:

UPDATE student SET address = ' welling street ' WHERE name = ' jack ' ;
ou
UPDATE student SET marks=marks+2 WHERE name = ' david ' ;

E se a actualização for em duas ou mais tabelas em simultâneo?

UPDATE tabela1, tabela2 , ...
SET

tabela1.Quantity = tabela1.Quantity + 1 ,
tabela2.InStock = tabela2.InStock - 1

WHERE tabela1.BookID = tabela2.BookID
AND tabela1.OrderID = 1002 ;



eliminação de dados | DELETE


j) eliminação de dados | DELETE
O comando DELETE serve então para apagar registos das tabelas e pode ser utilizado sem o
WHERE. No entanto, neste caso, todas as linhas da tabela indicada serão excluídas!! Portanto,
vamos utilizar o WHERE quando desejamos eliminar os registros que obedeçam a uma certa
condição.


DELETE FROM nomeTabela
[WHERE condição];
[LIMIT numeroLinhas]

Exemplo 1)
DELETE FROM Clientes;

Neste exemplo 1) seriam eliminados TODOS os registros da tabela Clientes na medida em
que não foi especiﬁcado nenhum critério (WHERE).

Exemplo 2)
DELETE FROM student WHERE name = ' michael ' LIMIT 10 ;

Já no exemplo 2, serão apagados no máximo 10 registos cujo name tenha o valor michael



operadores lógicos


k) operadores lógicos
Uma vez que estamos a utilizar o SGBD MySQL nas aulas, o MySQL suporta os seguintes
operadores lógicos:

AND ( && )

OR ( || )

NOT ( ! )


k) operadores lógicos | AND (&&)
The logical AND (&&) operator indicates whether the both operands are true. Lets see a
statement using AND operator.


SELECT studid, name FROM student WHERE marks > 80 AND marks < 100 ;

ou

SELECT studid, name FROM student WHERE marks > 80 && marks < 100 ;


k) operadores lógicos | OR ( | | )
The logical OR ( | | ) operator indicates whether the both operands are true. Lets see a statement
using AND operator.

Exemplo de utilização:

SELECT name, marks, address FROM student
WHERE name like ' a% ' OR name like ' s% ' ;

ou

SELECT name, marks, address FROM student
WHERE name like ' a% ' | | name like ' s% ' ;


k) operadores lógicos | NOT ( ! )
The logical NOT ( ! ) operator have only one operand and it returns the inverse of the value.

Exemplo de utilização:

SELECT * FROM cds WHERE jahr != 1999;
ou
SELECT * FROM cds WHERE NOT ( jahr = 1999 );
ou
SELECT * FROM cds WHERE ! ( jahr = 1999 );



consultas com
JUNÇÕES DE TABELAS


l) consultas c/ junção tabelas

INNER JOIN


l) consultas c/ junção tabelas | INNER JOIN
Caso exista uma relação entre as duas tabelas (1-1, 1-N), podemos fazer a consulta cujo resultado
mostra APENAS registos de ambas as tabelas que estejam unidos por uma chave (chave primária e
chave estrangeira).

Exemplo de aplicação com as tabelas CARROS e EMPREGADOS, onde cada empregado
(tabela EMPREGADOS) pode ter associado um carro (da tabela CARROS) via campo chave idCarro



SELECT EMPREGADOS.nomeEmpregado, EMPREGADOS.funcao, CARROS.fabricante, CARROS.modelo
FROM CARROS INNER JOIN EMPREGADOS
ON CARROS.idCarro = EMPREGADOS.idCarro ;



LEFT JOIN


l) consultas c/ junção tabelas | LEFT JOIN
Neste caso, com o LEFT JOIN são obtidos TODOS os carros, porque a primeira tabela
referenciada no JOIN (LEFT) é a tabela CARROS, e os registos que existirem relacionados com
esses carros na tabela de EMPREGADOS.

Para os carros que estão atribuídos a um empregado, a respectiva informação é incluída na
tabela. Os carros que não estão atribuidos, os campos nomeEmpregado e funcao aparecem
vazios (NULL)

FROM CARROS LEFT JOIN EMPREGADOS


l) consultas c/ junção tabelas | LEFT JOIN



RIGHT JOIN


l) consultas c/ junção tabelas | RIGHT JOIN
Neste caso, com o RIGHT JOIN são obtidos TODOS os empregados, porque a segunda tabela
referenciada no JOIN (RIGHT) é a tabela EMPREGADOS.

Para os funcionários a que está atribuído um carro, a respectiva informação é incluída na
tabela. Naqueles funcionários que têm o campo CarNo na tabela EMPLOYEES, os campos
Make e Model aparecem por consequência vazios...

FROM CARROS RIGHT JOIN EMPREGADOS


l) consultas c/ junção tabelas | RIGHT JOIN



transacções


n) transacções | conceito
Uma transacção num SGBD é uma sequência de instruções que deverá ser lida como uma
instrução indivisível. Todo o trabalho realizado pelas várias instruções deverá ser completado
ou então não poderá ser feito, mas nunca deverá ﬁcar uma parte feita e outra não. (deﬁnição e
exemplo em http://www.php-pt.com/index.php?
option=com_content&task=view&id=65&Itemid=28)

Sintaxe:
START TRANSACTION ;
instrucções de SQL ;
[ ROLLBACK ; ]
COMMIT ;

Ex. Imaginemos uma transferência de 1000€ da bancária da conta 2 para a conta 1

START TRANSACTION;
UPDATE contas SET saldo = saldo – 1000 WHERE numero_conta = 2;
UPDATE contas SET saldo = saldo + 1000 WHERE numero_conta = 1;

Caso algo corresse mal, poderíamos anular esta transacção
ROLLBACK;
Caso tudo tivesse corrido bem:
COMMIT;



integridade referencial


m) integridade referencial | conceitos
No MySQL também é possível propagar a integridade referencial entre os registos de tabelas
relacionadas entre si.

Essa propagação pode acontecer em dois momentos diferentes:

Quando acontece uma ACTUALIZAÇÃO do valor de uma chave primária (PRIMARY KEY);

Quando há uma ELIMINAÇÃO de um registo com um campo cuja chave primária está
envolvida em relações noutras tabelas (como chave estrangeira - FOREIGN KEY).


m) integridade referencial | conceitos
Quando o valor de um campo que é chave primária (primary key) for alterado ou o registo em si
for simplesmente apagado e essa chave deixar de existir, o SGBD poderá providenciar uma
destas cinco medidas que recairão sobre todos os registos que contenham a chave primária
sob a qual está a recair a operação de modiﬁcação/eliminação como chave estrangeira -
foreign key:

1. RESTRICT

2. CASCADE

3. SET NULL
Pre
4. NO ACTION 50
50
50
50


m) integridade referencial | RESTRICT
1. RESTRICT

Enquanto houver registos na base de dados cuja chave estrangeira é a chave primária da tabela
sobre a qual está a recair a operação de actualização / eliminação, a dita operação será sempre
abortada.

Assim, esta medida obriga a que todas as ocorrências dessa chave sejam apagadas primeiro.

Exemplo:

Se tentarmos apagar o produto Cadeira
da tabela PRODUTOS, uma vez que
há registos na tabela ENCOM_PROD Pre
com ID_Produto igual a 1, o SGBD não 50
50
será deixará alterar o ID_Produto de 1 50
50
para outro número nem permitirá que o
produto Cadeira (com o ID_Produto 1) seja apagado da tabela
PRODUTOS!


m) integridade referencial | CASCADE
2. CASCADE

Como o nome indica, aqui a propagação é efectuada em CASCATA.

Assim, esta medida obriga a que o SGBD efectue a actualização do novo valor da chave em todos
os registos relacionados ou efectue a eliminação de todas as ocorrências que tenham referência a
essa chave.

Exemplo:

Se tentarmos apagar o produto Cadeira
da tabela PRODUTOS, uma vez que
há registos na tabela ENCOM_PROD 44

com ID_Produto igual a 1, o SGBD irá Pre
50
apagar todos os registos da tabela 50
50
ENCOM_PROD que tenham como ID_ 44
50
Produto o número 1. Caso contrário, ﬁcariam encomendas com
referência a um produto que já não existia... (órfão!)

Em caso de uma actualização do valor ID_Produto da Cadeira da tabela PRODUTOS (de 1 para
100 por exemplo), TODOS os registos da tabela ENCOM_PROD onde actualmente têm
ID_PRoduto igual a 1, seriam actualizados pelo SGBD para 100.


m) integridade referencial | SET NULL
3. SET NULL

Neste caso, o SGBD deixa que os valores dos campos chave sejam modiﬁcados ou mesmo
eliminados.

No entanto, o valor das chaves que fazem referência a este campo terão o seu valor actualizado
para NULL. Útil pois posteriormente podemos fazer uma consulta e averiguar que registos têm
referências a chaves que já não existem (contêm valor NULL) e poderão depois ser tratados da
forma que se achar conveniente - SELECT * FROM nomeTabelaRelacionada WHERE
nomeCampoChaveEstrangeira is NULL;

NULL

NULL
Pre
NULL 50
50
50
50


m) integridade referencial | NO ACTION
4. NO ACTION

Neste caso, o SGBD “fecha os olhos” ao erro grave de quebra de integridade que está a
acontecer... não acontece nada aos registos que têm referência a esta chave que acabou de ser
alterada ou apagada.

Esta situação será de eviar na medida em que haverá registos que vão ﬁcar orfãos! Senão
vejamos: Se apagarmos o PRODUTO com ID_Produto 2 da tabela PRODUTOS ( mesa de sala ),
vai continuar a haver registos referentes a esse produto perdidos e sem “pai” na tabela
ENCOM_PROD!

Pre
50
50
50
Qual é o nome do produto 50
com ID_Produto = 2?!
Não existe nenhum produto com
ID_Produto = 2...


m) integridade referencial | SET DEFAULT
4. SET DEFAULT

Ainda não suportado pelo SGBD MySQL!!

Na prática acontece quase o mesmo do que na opção SET NULL mas em vez dos valores da
chave estrangeira ficarem vazios (NULL) ficarão com o seu valor predefinido (DEFAULT).


m) integridade referencial | revisão fk
A chave estrangeira (foreign key) é uma cláusula que deve ser incluída quando possuímos
duas tabelas relacionadas numa base de dados.

Através da chave estrangeira estabelecemos as relações entre duas ou mais tabelas.

A chave estrangeira desta forma referencía o campo que é chave primária na tabeça
relacionada.

(
name VARCHAR(30) ,


) ENGINE = InnoDB ;


m) integridade referencial | revisão fk
Implementando a chave estrangeira através do método de CONSTRAINT:

(
name VARCHAR(30) ,
class INT ,


) ENGINE = InnoDB ;


m) integridade referencial | implementação
No MySQL também é possível propagar a integridade referencial entre os registos de tabelas
relacionadas entre si.

A sintaxe é a seguinte:

[ON DELETE {RESTRICT | CASCADE | SET NULL | NO ACTION | SET
DEFAULT }]

[ON UPDATE {RESTRICT | CASCADE | SET NULL | NO ACTION | SET
DEFAULT }]


Implementando a propagação da ELIMINAÇÃO ( ON DELETE ) através do método de escrita
em linha:

(
name VARCHAR(30) ,

[ ON DELETE { RESTRICT | CASCADE | SET NULL | NO ACTION | SET
DEFAULT } ]

[ ON UPDATE { RESTRICT | CASCADE | SET NULL | NO ACTION | SET
DEFAULT } ]

) ENGINE = InnoDB ;


Implementando a propagação da ELIMINAÇÃO ( ON DELETE ) através do método de
CONSTRAINT:

(
name VARCHAR(30) ,
class INT ,


[ ON DELETE { RESTRICT | CASCADE | SET NULL | NO ACTION | SET
DEFAULT } ]

[ ON UPDATE { RESTRICT | CASCADE | SET NULL | NO ACTION | SET
DEFAULT } ]

) ENGINE = InnoDB ;


Linguagem SQL (com MySQL)

Mais conteúdo relacionado

Mais procurados

Destaque

Semelhante a Linguagem SQL (com MySQL)

Mais de Marco Pinheiro

Linguagem SQL (com MySQL)