Structured Query Language Armando B.

Mendes e Elisabete Freire, FCT-UAc

Structured Query Language

• Interpretar a história e regras do SQL no
desenvolvimento das Bases de Dados;
• Definir termos como esquema, catálogo, DDL,
DML, DCL;
• Definir uma Base de Dados utilizando DDL;
• Perceber para que serve e o que é a integridade
referencial;
• Estabelecer integridade referencial, utilizando SQL;
• Perceber e utilizar diferentes tipos de join.
• Escrever comandos SQL simples e múltiplos;
• Entender o uso de triggers e store procedures.
26/05/2020 1

Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

O que é o SQL:
• SQL é sigla inglesa de Structured Query
Language que significa, Linguagem de Consulta
Estruturada;
• linguagem considerada padrão na gestão de
dados e que permite programar as principais
bases de dados baseadas no modelo relacional.
• Usada nos principais sistemas de gestão de
dados: MySQL (open source), Oracle, Firebird,
Microsoft SQL Server, PostgreSQL (open source),
HSQLDB (open source em Java).

26/05/2020 2

2
 Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

História: O princípio da SQL:

• Tal como os conceitos base dos SGBD, também foi na IBM que se desenvolveram
os 1ºs esforços para conceção desta linguagem entre 1974 e 1979:
• Baseado na SEQUEL (“Structured English QUEry Language”) desenvolvida pela IBM;
• As primeiras implementações foram no SGBDR System R da IBM (1977), esse
sistema foi criado com base num artigo de 1970 escrito por Edgar F. Codd.
• o 1º SGBDR comercial que a utilizou foi o Oracle (1979);
• É uma norma da American National Standards Institute (ANSI) desde 1986. É um
Federal Information Processing Standard (FIPS) e é reconhecida pelo International
Organization for Standardization (ISO) em 1987.
• teve já várias versões: SQL/86, SQL/89, SQL/92 (SQL2), SQL:2003,…
• Muitos construtores introduziram melhorias específicas, pelo que nem todas as
versões de SQL são compatíveis entre si.

26/05/2020 3

Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

História: O princípio da SQL:

O propósito original do standard SQL foi:
• Especificar a sintaxe e a semântica para a definição e
manipulação de dados;
• Definir as estruturas de dados e as operações básicas
para desenhar, aceder, manter, controlar e proteger as
Bases de Dados;
• Permitir a portabilidade da definição da Base de Dados e
de módulos aplicacionais entre diferentes SGBD;
• Especificar standards mínimos (nível 1) e completos(nível
2), que permitam diferentes adaptações de produtos;
• Permitir um standard inicial, se bem que incompleto, que
possa ser melhorado posteriormente para incluir
especificações que permitam o tratamento da
integridade referencial, gestão de transações, operações
de join, a utilização de charater sets, etc.
26/05/2020 4

4
 Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

História: Evolução do MySQL:

Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

Objetivo
Linguagem usada pelo gestor de base de dados para proporcionar aos
utilizadores funções de definição, extração (retrieval), manipulação e
controlo (partilha e integridade) dos dados.
Vantagens na utilização da SQL:
• Baseada na álgebra relacional, com sólidas fundações matemáticas;
• Orientada para conjuntos (“set-oriented language”);
• Linguagem Declarativa, apenas se indica o objetivo pretendido
ficando a cargo do engine todas as tarefas de execução e otimização.
• Independência do vendedor;
• Portabilidade entre sistemas, no caso de se usarem os Standards
definidos nas normas dos sistemas de qualidade;
• Aval da IBM e comprometimento da Microsoft (ODBC);
• Estruturas de alto nível, semelhante à linguagem natural Inglês.
Referencias:
Damas: p. 1-3, 265-284
26/05/2020 6
Pereira: p. 199-200; 214-221

6
 Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

Funções da linguagem SQL:

• Consultas ad hoc e interativas
• Acesso às bases de dados em modo de programação
• Múltiplas visões dos dados
• Linguagem de base de dados completa
• Definição dinâmica de dados
• Arquitetura cliente/servidor
• Permite criar BDs distribuídas ou mesmo uma gateway de base de dados
• Conjunto de instruções completo para administração da base de dados
• No entanto não é uma linguagem imperativa porque:
• não inclui ciclos;
• originariamente não tinha estruturas de decisão if ou switch;
• não tem possibilidade de recursividade;
• não tem a possibilidade de realizar Input e Output de
valores ou resultados.

26/05/2020 7

Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

• Triggers e procedimentos
armazenados (store procedures);
• SQL/PSM (Persistent Stored Modules);
• Regras para construção de bases de
conhecimento e sistemas periciais;
• Acesso aleatório a dados
(random retrieval);
• Tipos de dados complexos
(BLOb - Binary Large Object );

26/05/2020 8

8
 Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

Sublinguagens:
• Linguagem de Definição de
Dados (LDD) ou Data
Definition Language (DDL)
usada para criar, alterar e
apagar tabelas. Está
restringida, normalmente,
aos Administradores de Bases de Dados; Ex.: CREATE {SCHEMA |
• instrução para a criação (CREATE) DATABASE} <identificador>;
• instrução para alteração (ALTER) cria as tabelas de sistema para
• instrução para remoção (DROP) uma nova BD no servidor
• Linguagem de Manipulação de Dados (LMD) ou DML - Data Manipulation
Language, conjunto de comandos usados para inserir, atualizar, modificar e
questionar, os dados. Podem ser usados interactivamente, permitindo uma
resposta imediata, após a execução do comando. Podem classificar-se em
dois grupos:
• Interrogação da base de dados: (instrução SELECT)
• Atualização da base de dados (instruções INSERT, DELETE e UPDATE)
26/05/2020 10

10

Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

Sublinguagens SQL:
• Linguagem de Controlo de Dados (LCD) ou Data Control Language
(DCL), conjunto de comandos usado para definir permissões de
manipulação de dados, para utilizadores e grupos de utilizadores.
• GRANT atribuição de privilégios
• REVOKE remoção de privilégios

• TCL (Transaction Control Language) - As declarações TCL permitem o

controlo e gestão de transações para manter a integridade dos dados
nas instruções SQL, evita que um conjunto de comandos SQL seja
executado se um deles falhar impedindo as operações de ficar apenas
parcialmente executadas.
• BEGIN Transaction - abre uma transação
• COMMIT Transaction – fecha uma transação e executa tornando
as alterações permanentes desde que todas as instruções
terminem com sucesso.
• ROLLBACK Transaction - reverte uma transação a pedido do
programador.
26/05/2020 11

11
 Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

Linguagem de Definição de Dados

• CREATE TABLE
define uma nova tabela e as suas colunas.
• DROP TABLE
destrói uma tabela incluindo definição,
conteúdo, views e índices;

DROP TABLE Alunos;

• ALTER TABLE – adiciona uma ou mais colunas a

uma tabela. Alguns SGBDR’s também permitem
apagar e redefinir o tipo de dados das colunas;

ALTER TABLE Alunos

ADD COLUMN nacionalidade CHAR(15);
26/05/2020 12

12

Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

Exemplo:
CREATE TABLE Alunos (
Cod_Aluno SMALLINT PRIMARY KEY,
Nome CHAR(20) NOT NULL,
Idade SMALLINT,
Cod_Curso SMALLINT,
FOREIGN KEY (Cod_Curso)
REFERENCES Cursos (Cod_Curso)
ON UPDATE CASCADE Integridade
referencial
ON DELETE SET NULL,
Verificação
CHECK (Idade BETWEEN 17 AND 70)) extra
26/05/2020 13

13
 Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

Ler a Sintaxe de um Comando

CREATE TABLE <nome_da_tabela> (
<atributo1> <tipo> [(<parâmetro>)] [NULL| NOT NULL] [INDEX],
<atributo2> <tipo> [(<parâmetro>)] [NULL| NOT NULL] [INDEX],
...,
CONSTRAINT <nome> <restrições>)

• O <tipo> representa o domínio do atributo.

• Cores: azul - comandos, cinzento - a substituir por
valores concretos, preto - obrigatório,
vermelho - símbolos de sintaxe:
• parêntesis retos - conteúdo opcional.
• chavetas - pelo menos um é obrigatório.
• traço vertical – alternativo.

26/05/2020 14

14

Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

Sintaxe no MySQL
CREATE [TEMPORARY] TABLE [IF NOT EXISTS] tbl_name
(create_definition,...)
[table_options] Continua abaixo
[partition_options]

CREATE [TEMPORARY] TABLE [IF NOT EXISTS] tbl_name

[(create_definition,...)]
[table_options]
[partition_options]
[IGNORE | REPLACE] MAIÚSCULAS -> comandos;
[AS] query_expression minúsculas -> substituir por
um valor ou a instrução
CREATE [TEMPORARY] TABLE [IF NOT EXISTS] tbl_name continua;
{ LIKE old_tbl_name | (LIKE old_tbl_name) } Parêntesis retos, chavetas e
barras verticais -> símbolos
create_definition: de sintaxe.
col_name column_definition
| [CONSTRAINT [symbol]] PRIMARY KEY [index_type] (index_col_name,...)
[index_option] ...
| {INDEX|KEY} [index_name] [index_type] (index_col_name,...)
26/05/2020 15

15
 Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

Utilização de Índices:
Um índice, criado fisicamente em memória, permite um mais rápido
acesso aos dados, e diversas ordenações dos valores dos atributos
(não implementado no MySQL). Duas instruções:
restrição para todos os valores distintos
• criar um índice a partir de uma ou várias coluna: ASCendente
CREATE [UNIQUE] INDEX<nome_indíce> DEScendente
ON <nome_da_tabela> ( <nome_atributo1> [ASC|DES], ...);
se vários atributos,
o valor do índice é
• apagar um índice da memória: a concatenação
DROP INDEX <nome_indíce> ON <nome_da_tabela>

Ex.:
CREATE INDEX Chave_prim
ON Clientes (Cod_cliente);

➢ Os índices são automaticamente atualizados pelo SGBDR sempre

que um valor é alterado, inserido ou apagado.
➢ As restrições PRIMARY KEY e FOREIGN KEY são sempre indexadas.
26/05/2020 16

16

Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

Restrições de Integridade
Restrições de domínio:
• Forma elementar de restrição;
• Está relacionada com a representação de dados em memória;
• Limitam o domínio de valores possíveis para uma coluna;
• Evita que se introduzam valores incongruentes na mesma
coluna, por exemplo idade em números e em texto;
• Inclui um conjunto de parâmetros como NULL e UNIQUE;

Restrições de integridade referencial:

• permitem garantir a integridade do modelo relacional
evitando registos órfãos.
• Duas principais proteções: atualização do valor de chaves
primárias ou eliminação de valores em chaves primárias.

26/05/2020 17

17
 Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

Restrições de domínio e tipos de dados

• Numeric
• Todo o tipo de valores numéricos
• Integer (inteiros) -> 2
• Floating point (números com parte decimal [, ou .]) -> 2,345
• Date and Time
• Dados relacionados com datas, horas, ...
• String
• Sequência de caracteres, texto, símbolos (frases, palavras)
• BLOB (Binary Large Object)
• Para ficheiros multimédia: imagens, sons, vídeos…
• Geometry
• para dados geográficos e construção de SIGs
• define atrributos como conjuntos de pontos (multipoint) ou linhas
(LineString e MultiLineString), por exemplo.

26/05/2020 18

18

Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

Dados numéricos inteiros (MySQL)

TINYINT: 1 Byte Signed
• -128 ... 127 ou 0 ... 255 Unsigned

SMALLINT: 2 Bytes
• -32768 ... 32767 ou 0 ... 65535
MEDIUMINT: 3 Bytes
• -8388608 ... 8388607 ou 0 ... 16777215
INT: 4 Bytes
• -2147483648 ... 2147483647 ou 0 ... 4294967295
BIGINT: 8 Bytes
• -9223372036854775808 ... 9223372036854775807
ou 0 ... 18446744073709551615
BOOL, BOOLEAN
• FALSE = 0, TRUE ≠ 0
A maioria destes tipos aceita uma máscara (valor numérico inteiro
entre parêntesis) que não altera a memória ocupada pelo valor.
26/05/2020 19

19
 Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

Dados numéricos com parte decimal (MySQL)

neste caso não é
DECIMAL
uma máscara
• Formato que permite especificar parâmetros
para a parte decimal e o número de dígitos
DOUBLE
• -1,798E+308 ... -2,225E-308 Signed
• 2,225E-308...1,798E+308 Unsigned

FLOAT
• -3,403E+38 ... -1,175E-38
• 1,175E-38...3,403E+38

26/05/2020 20

20

Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

Funções e operadores para dados numéricos

Name Description https://dev.mysql.com/doc/refman/5.7/en/numeric-functions.html
ABS() Return the absolute value
ACOS() Return the arc cosine
O MySQL 5.7 não
ASIN() Return the arc sine
ATAN() Return the arc tangent aceitava espaços entre
ATAN2(),
Return the arc tangent of the two arguments o identificador e os ()
ATAN()
CEIL(),
Return the smallest integer value not less than the
CEILING()
argument (arredonda por exceço)
Name Description
CONV() Convert numbers between different number bases + Addition operator
COS() Return the cosine POW(),
Return the argument raised to the specified power
COT() Return the cotangent POWER()
CRC32() Compute a cyclic redundancy check value RADIANS() Return argument converted to radians
DEGREES() Convert radians to degrees RAND() Return a random floating-point value
DIV Integer division Arredonda o argumento para o nº de casas decimais
ROUND()
EXP() Raise to the power of indicado num parâmetro
Return the largest integer value not greater than the SIGN() Return the sign of the argument
FLOOR()
argument (arredonda por defeito) SIN() Return the sine of the argument
LN() Return the natural logarithm of the argument SQRT() Return the square root of the argument
Return the logarithm of the first argument, the second TAN() Return the tangent of the argument
LOG()
is base * Multiplication operator
LOG10() Return the base-10 logarithm of the argument TRUNCATE() Truncate to specified number of decimal places
LOG2() Return the base-2 logarithm of the argument - Change the sign of the argument
- Minus operator MOD() %,
Return the remainder, resto da divisão inteira
MOD
26/05/2020 21

21
 Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

Dados Date e Time

DATE
• YYYY-MM-DD ➢ Os campos deste tipo aceitam
diversos formatos, que o MySQL
TIME
tenta interpretar, mas são guardados
• HH:MM:SS sempre no formato indicado.
DATETIME ➢ Um formato não previsto pode dar
resultados inesperados.
• YYYY-MM-DD HH:MM:SS
➢ Usar sempre ano-mês-dia.
YEAR (4 | 2)
➢ Se forem usados dois dígitos para o
• YYYY (1901 … 2155) ano, o MySQL usa:
• 70-99 convertido em 1970-1999
TIMESTAMP (M)
• 00-69 convertido em 2000-2069
• (14) YYYY-MM-DD HH:MM:SS ➢ O MySQL converte os tipos data em
• (8) YYYY-MM-DD numéricos ou strings de acordo com
• (4) YY-MM as operações efetuadas:
• (2) YY mysql> SELECT CURDATE(); -> '2008-06-13'
mysql> SELECT CURDATE() + 0; -> 20080613

26/05/2020 22

22

Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

Funções para dados Date e Time

Name Description Name Description
https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html
ADDDATE() MONTHNAME() Return the name of the month
Add time values (intervals) to a date value
DATE_ADD() PERIOD_ADD() Add a period to a year-month
ADDTIME() Add time PERIOD_DIFF() Return the number of months between periods
CONVERT_TZ() Convert from one time zone to another QUARTER() Return the quarter from a date argument
CURDATE(), CURRENT_DATE(), CURRENT_DATE SEC_TO_TIME() Converts seconds to 'HH:MM:SS' format
CURRENT_TIME(), CURRENT_TIME SECOND() Return the second (0-59)
Return the current date STR_TO_DATE() Convert a string to a date
CURRENT_TIMESTAMP(), CURRENT_TIMESTAMP, NOW(), SUBDATE() = DATE_SUB() when invoked with 3 arguments
LOCALTIME(), LOCALTIME, LOCALTIMESTAMP, LOCALTIMESTAMP() SUBTIME() Subtract times
CURTIME() Return the current time SYSDATE() Return the time at which the function executes
DATE() Extract the date part of a date or datetime TIME() Extract the time portion of the expression
Add time values (intervals) to a date value TIME_FORMAT() Format as time
DATE_FORMAT() Format date as specified TIME_TO_SEC() Return the argument converted to seconds
DATE_SUB() Subtract a time value (interval) from a date TIMEDIFF() Subtract time
DATEDIFF() Subtract two dates With a single argument, returns the date or
DAYNAME() Return the name of the weekday TIMESTAMP() datetime expression; with two arguments, the
DAYOFMONTH(), DAY() sum of the arguments
Return the day of the month (0-31) TIMESTAMPADD() Add an interval to a datetime expression
DAYOFWEEK() Return the weekday index of the argument TIMESTAMPDIFF() Subtract an interval from a datetime expression
DAYOFYEAR() Return the day of the year (1-366) TO_DAYS() Return the date argument converted to days
EXTRACT() Extract part of a date Return the date or datetime argument
TO_SECONDS()
FROM_DAYS() Convert a day number to a date converted to seconds since Year 0
GET_FORMAT() Return a date format string UTC_DATE() Return the current UTC date
HOUR() Extract the hour UTC_TIME() Return the current UTC time
LAST_DAY Return the last day of the month UTC_TIMESTAMP() Return the current UTC date and time
MAKEDATE() Create a date from the year and day of year WEEK() Return the week number
MAKETIME() Create time from hour, minute, second WEEKDAY() Return the weekday index
MICROSECOND() Return the microseconds from argument WEEKOFYEAR() Return the calendar week of the date (1-53)
MINUTE() Return the minute from the argument YEAR() Return the year 23
MONTH() Return the month from the date passed YEARWEEK() Return the year and week

23
 Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

Dados String
CHAR(M)
• 1-255: sequência de caracteres de tamanho fixo,
sem parêntesis: apenas um caracater.
VARCHAR(M)
• Sequência de caracteres de tamanho variável
• Pode armazenar até um máximo de M caracteres
• Otimiza o espaço necessário ao armazenamento
TINYTEXT
• 255 caracteres
TEXT
• 65 535 caracteres
MEDIUMTEXT
• 16 777 215 caracteres
LONGTEXT
• 4 294 967 295 caracteres

26/05/2020 24

24

Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

Funções para Dados String Name Description

Name Description
Return the string argument, left-padded with the
ASCII() Return numeric value of left-most character LPAD()
specified string
Return a string containing binary
BIN() LTRIM() Remove leading spaces
representation of a number
https://dev.mysql.com/doc/refman/8.0/en/string-functions.html

Return a set of comma-separated strings that

BIT_LENGTH() Return length of argument in bits MAKE_SET()
have the corresponding bit in bits set
CHAR() Return the character for each integer passed
MATCH Perform full-text search
CHAR_LENGTH(),
Return number of characters in argument Return a substring starting from the specified
CHARACTER_LENGTH() MID()
position
CONCAT() Return concatenated string
NOT LIKE Negation of simple pattern matching
CONCAT_WS() Return concatenate with separator
NOT REGEXP Negation of REGEXP
ELT() Return string at index number
ORD() Return character code for leftmost character
Return a string such that for every bit set in
QUOTE() Escape the argument for use in an SQL statement
EXPORT_SET() the value bits, you get an on string and for
REGEXP, RLIKE Pattern matching using regular expressions
every unset bit, you get an off string
Return the index (position) of the first REPEAT() Repeat a string the specified number of times
FIELD() REPLACE() Replace occurrences of a specified string
argument in the subsequent arguments
Return the index position of the first REVERSE() Reverse the characters in a string
FIND_IN_SET() RIGHT() Return the specified rightmost number of charact.
argument within the second argument
Return a number formatted to specified RPAD() Append string the specified number of times
FORMAT()
number of decimal places RTRIM() Remove trailing spaces
Insert a substring at the specified position up SOUNDEX() Return a soundex string
INSERT()
to the specified number of characters SOUNDS LIKE Compare sounds
Return the index of the first occurrence of SPACE() Return a string of the specified number of spaces
INSTR()
substring STRCMP() Compare two strings
Return the leftmost number of characters as SUBSTR(),
LEFT() Return the substring as specified
specified SUBSTRING()
LENGTH() Return the length of a string in bytes Return a substring from a string before the
SUBSTRING_INDEX()
LIKE Simple pattern matching specified number of occurrences of the delimiter
LOAD_FILE() Load the named file TRIM() Remove leading and trailing spaces
Return the position of the first occurrence of UPPER(), UCASE() Convert to uppercase
LOCATE(), POSITION()
substring WEIGHT_STRING() Return the weight string for a string 25
LOWER(), LCASE() Return the argument in lowercase

25
 Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

Dados String – vou aqui

Strings de elementos

• Definem uma gama de valores possíveis,

para os dados a armazenar;

• São pouco eficientes na gestão de memória,

usar com cuidado.

ENUM (<elemento1>, <elemento2>, ...,<elemento65535>)

• Armazena um elemento do conjunto

SET (<elemento1>, <elemento2>, ..., <elemento64>)

• Armazena zero ou mais elementos do conjunto

(campo multivalor)
26/05/2020 26

26

Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

Dados Binários ou Complexos

BLOB (Binary Large Object)

• Sequência de caracteres que codificam uma imagem, som, vídeo, etc.

• 65 535 caracteres

TINYBLOB

• 255 caracteres

MEDIUMBLOB

• 16 777 215 caracteres

LONGBLOB

• 4 294 967 295 caracteres

26/05/2020 27

27
 Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

Parâmetros de domínio:
(PK) PRIMARY KEY = NOT NULL + UNIQUE
• Transforma a coluna numa chave primária
• Nessa coluna não poderão existir valores nulos ou repetidos
• Identifica de forma unívoca cada novo registo na tabela
(NN) NOT NULL
• Nessa coluna não poderão existir valores NULL ou vazios
• Usar em chaves estrangeiras no caso de obrigatoriedade
(UQ) UNIQUE
• Na coluna todos os
valores serão únicos
(incluindo os NULL)
• Usado em chaves
estrangeiras em
relações 1:1

26/05/2020 28

28

Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

Restrições de domínio:
(ZF) ZEROFILL

• Preenche com zeros à esquerda a representação de um valor numérico • 5 -> 000005

(AI) AUTO INCREMENT

• Auto incrementa o valor inteiro a cada novo registo (último valor +1)

• Usado normalmente com chaves primárias (PK)

Usar INT nas chaves
estrangeiras
(BIN) BINARY correspondentes
• Usado com os tipos CHAR e VARCHAR

Default

• Atribui um valor por defeito para a coluna, pode ser alterado pelo utilizador.
• Usar quando uma coluna tem frequentemente um valor.

(UN) UNSIGNED

• Permite armazenar apenas valores positivos (sem sinal) do tipo de dados selecionado
• Pode ser combinado com inteiros, floats e chars.
26/05/2020 29

29
 Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

Outras Restrições:
Introduzem igualmente restrições de integridade \ qualidade dos dados as
seguintes clausulas:

clausula FOREIGN KEY … REFERENCES

• Cria uma ligação entre duas tabelas indicando os atributos comuns;
• As colunas nas duas tabelas têm de ter igual domínio.
clausula CHECK
• implementa uma restrição que verifica os dados introduzidos num atributo
com base numa expressão que pode envolver vários atributos;
CREATE TABLE Alunos (Cod_Aluno SMALLINT PRIMARY KEY, Idade SMALLINT, CHECK (Idade
BETWEEN 17 AND 70))
• esta clausula é aceite pelo parser mas não está implementada no MySQL
• Para implementar este tipo de restrições usar: triggers ou outra tabela com
os valores permitidos (se discretos) e uma restrição de foreign key:
CONSTRAINT <nome_restrição> FOREIGN KEY (<atributo>) REFERENCES <tabela> (<atributo>)

26/05/2020 30

30

Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

Exemplos de restrições ao domínio

CREATE TABLE alunos(
num_aluno NUMBER(6) NOT NULL,
nome VARCHAR(30) NOT NULL,
local VARCHAR(25),
data_nsc DATE NOT NULL,
sexo CHAR(1) NOT NULL CHECK ( sexo IN ( 'F' , 'M' ) ),
cod_curso NUMBER(3) NOT NULL);

CREATE TABLE produtos(

id_produto NUMBER(6) NOT NULL,
nome VARCHAR(30) NOT NULL,
iva NUMBER(2) NOT NULL CHECK ( iva IN (0, 4, 9, 16) ) );

CREATE TABLE branch(

branch_name CHAR(15),
branch_city CHAR(30),
assets NUMBER CHECK (assets >= 0));
26/05/2020 31
@Silberschatz et al. (Adaptado)

31
 Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

Integridade Referencial
• Numa cadeia de dependências de chaves externas, a integridade referencial
permite que uma remoção ou atualização num dos extremos se propague
através de toda a cadeia.
CREATE TABLE account
. . . FOREIGN KEY(branch_name)
REFERENCES branch ON DELETE CASCADE
ON UPDATE CASCADE . . . )
• Com as cláusulas ON DELETE CASCADE, se a remoção de um tuplo na relação
branch resulta na violação da restrição da integridade referencial, a remoção
propaga-se em “cascata” para a relação account, removendo o tuplo que referia
a agência que tinha sido eliminada. Atualizações em cascata são semelhantes.
• Se uma remoção ou atualização em cascata origina uma violação de uma
restrição que não possa ser tratada por outra operação em cascata, o sistema
aborta a transação. Logo, todas as alterações e respetivas ações em cascata
serão anuladas.
• Alternativas às operações em cascata:
• ON DELETE SET NULL
• ON DELETE SET DEFAULT
26/05/2020 32

32

Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

Motores de armazenamento para tabelas No MySQL

MyISAM
• Motor mais antigo no MySQL
• Maior portabilidade das tabelas
• Armazena mais dados, num menor espaço
• Permite a compressão dos dados
• Usado para data warehouses e outras formas
desnormalizadas

InnoDB
• Storage Engine por defeito
• Suporta chaves estrangeiras
• Mecanismos de recuperação (rollback)
• Princípio ACID para transações Atomicity, Consistency,
Isolation e Durability
26/05/2020 33

33
 Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

Motores de armazenamento para tabelas MySQL

• Memory: Stores all data in RAM, for fast access in
environments that require quick lookups of non-critical data.

• CSV: Its tables are really text files with comma-separated

values. Because CSV tables are not indexed, you typically
keep the data in InnoDB tables during normal operation, and
only use CSV tables during the import or export stage.

• Archive: These compact, unindexed tables are intended for

storing and retrieving large amounts of seldom-referenced
historical, archived, or security audit information.

• NDB (also known as NDBCLUSTER): This clustered

database engine is particularly suited for applications that
require the highest possible degree of uptime and availability.

• Federated: Offers the ability to link separate MySQL

servers to create one logical database from many physical
servers. Very good for distributed or data mart environments.
26/05/2020 34

34

Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

DML Comando SELECT

SELECT - seleciona um conjunto de atributos de uma(s) tabela(s) dada(s)
pelo comando FROM e um conjunto de linhas com o comando WHERE.
O resultado de uma consulta SQL é uma relação \ tabela.
• Sintaxe:
SELECT {* | <atributo1>}[, <atributo2> , ... ]
FROM <nome_tabela1>[, <nome_tabela2>, ...]
[WHERE <condição>] ;

• Exemplo: lista de Cod_aluno, Nome, Morada da tabela Aluno

SELECT Cod_aluno, Nome, Morada
FROM Aluno;

• O SQL é baseada em operações de conjuntos e de álgebra relacional

com algumas modificações e extensões.
26/05/2020 35

35
 Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

Esquema Relacional do Banco

Para exemplos:

Ciclo: permite identificar o balcão

onde foi efetuado o empréstimo,
não obriga a ser um dos vários
balcões onde o cliente tem contas
26/05/2020 36

36

Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

DML Comando SELECT

• Exemplo: Listar os nomes de todas as agências na relação loan
SELECT branch_name
FROM loan;

• Um asterisco na cláusula SELECT denota “todos os atributos”

SELECT *
FROM loan

• O SQL não permite utilizar o caracter ‘-’ nos identificadores, portanto

deverá utilizar, por exemplo, branch_name em vez de branch-name.
• SQL não é uma linguagem case sensitive, pelo que é indiferente usar
maiúsculas ou minúsculas.
• São boas práticas utilizar as palavras chave da linguagem em
maiúsculas.
26/05/2020 37

37
 Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

DML Comando SELECT

• O comando SELECT permite incluir expressões aritméticas
e modificar o nome das colunas na tabela resultado.
• Uma expressão pode ser uma combinação de valores,
operadores e funções que produzem um valor.
• Os operadores aritméticos são:
+ Soma
- Subtração
* Multiplicação
/ Divisão novo nome da
coluna resultante do
• Exemplo: Listar código de empregado atributo calculado
e o ordenado anual calculado
SELECT Cod_emp, Ordenado, Ordenado*14 AS ‘Ordenado anual’
FROM Empregado;
26/05/2020 38

38

Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

DML Comando SELECT

• O comando ORDER BY é utilizado para ordenar linhas.
SELECT {* | <atributo1>}[, <atributo2> , ... ]
FROM <nome_tabela1>[, <nome_tabela2>, ...]
[WHERE <condição>] ;
[ORDER BY {<atributo> [ASC|DESC], <atributo> [ASC|DESC], …}]
• Pode-se especificar DESC para ordenação descente ou ASC
para ordenação ascendente, para cada atributo; por
omissão, assume-se ordem ascendente.
• Exemplo: as linhas ordenadas por código de departamento
que, por defeito, é realizado de forma ascendente, no caso
de empates usar ordem inversa de ano de contratação:

SELECT Cod_Depar, Cargo

FROM Empregado
ORDER BY Cod_Depar, Ano_Contra DESC;
26/05/2020 39

39
 Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

DML Comando SELECT

• Também se pode usar LIMIT combinado com OFFSET para escolher o(s)
primeiro(s) ou sublista de uma lista ordenada:
SELECT {* | <atributo1>}[, <atributo2> , ... ]
FROM <nome_tabela1>
[WHERE <condição>] ;
[ORDER BY <atributo> [ASC|DESC] [, <atributo> [ASC|DESC], …] ]
[LIMIT [<nºlinhas salta desde inicio>,] <nºLinhas apresenta> | OFFSET <nº linhas salta>] ]
• Exemplo: da query anterior escolher os dois primeiros clientes:
SELECT Cod_Depar, Cargo FROM Empregado
ORDER BY Cod_Depar, Ano-Contra DESC
LIMIT 2;
• Exemplo: da query anterior para os clientes entre a 3ª e 5ª posição (inclusive)
SELECT Cod_Depar, Cargo FROM Empregado
ORDER BY Cod_Depar, Ano-Contra DESC
3 OFFSET 5; | LIMIT 5,8;

26/05/2020 40

40

Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

DML Comando SELECT Não acontece na

• O SQL permite duplicados nas tabelas e nos álgebra relacional
resultados de consultas.
• Para forçar a eliminação de duplicados, inserir a
palavra-chave DISTINCT.
• Ex.: Apresentar os nomes de todos os balcões onde
foram efetuados empréstimos, sem repetições:
SELECT DISTINCT branch_name, amount
FROM loan
ORDER BY branch_name;
• A palavra-chave ALL indica que os duplicados não
devem ser removidos.
• Exemplo: igual mas com repetições
SELECT ALL branch_name
FROM loan
26/05/2020 41

41
 Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

DML Comando SELECT

• O comando WHERE corresponde ao operador de
seleção da álgebra relacional.
• O comando WHERE é utilizado a seguir ao comando
FROM e contém uma(s) condição(s) que as linhas
têm que satisfazer.
• O comando WHERE deverá possuir três elementos:
1. O nome do atributo.
2. O operador de comparação.
3. O nome de um atributo, uma constante ou uma lista
de valores.
• Exemplo: Para encontrar os números de contas da
agência da Horta com saldos superiores a 100.
SELECT account_number
FROM account
WHERE branch_name = ‘ Horta’ AND balance > 100
26/05/2020 42

42

Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

DML Comando SELECT

• Os operadores de comparação podem ser divididos em
duas categorias: lógicos e operadores SQL.
• Os operadores lógicos são:
= igual a
> maior que
>= maior ou igual que
< menor que
<= menor ou igual que
<> ou != diferente
<=> igual excluindo NULLs
• Operadores SQL operam sobre todos os tipos de dados:
BETWEEN <expressão> AND <expressão> entre dois valores
IN(<lista>) pertence a qualquer valor da lista Corresponde
LIKE <string> comparação com wild cards (% ou _) a um caracter
IS <condição> comparação com booleano Corresponde
IS NULL é um valor nulo a qualquer nº
COALESCE (<lista>) dá o primeiro elemento da lista de caracteres
não NULL
26/05/2020 43

43
 Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

DML Comando SELECT

• Exemplo: Selecionar Nome, Cargo, Código de
Departamento da tabela empregado se o cargo for
secretário:
SELECT Nome, Cargo, Cod_Depar FROM Empregado
WHERE Cargo='Secretario';
• Exemplo: Selecionar nome e número de superior da
tabela empregado para os números 7902,7566,7788
SELECT Nome, N_Superior FROM Empregado
WHERE N_Superior IN (7902,7566,7788);
• Exemplo: Selecionar empregados com nome
começados por S
SELECT Nome FROM Empregado
WHERE Nome LIKE 'S%’;
• Exemplo: Listar os clientes cuja rua inclua a subcadeia “Main”.
SELECT customer_name FROM customer
26/05/2020 WHERE customer_street LIKE ‘%Main%’ 44

44

Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

DML Comando SELECT

Os operadores SQL têm as respetivas expressões de negação:
NOT BETWEEN <expressão> AND <expressão>
fora do intervalo
NOT IN(<lista>) não corresponde a nenhum dos
valores da lista
NOT LIKE <string> cadeias de caracteres que
não satisfazem uma condição
IS NOT <condição> não é
IS NOT NULL é um valor não nulo
• Exemplo: Nome e número de superior para empregados que têm
um superior:
SELECT Nome, N_Superior
FROM Empregado
WHERE N_Superior IS NOT NULL;
• Exemplo: Nome e Ordenado de empregados com ordenados fora do
intervalo de 100 mil a 200 mil:
SELECT Nome, Ordenado
FROM Empregado
26/05/2020
WHERE Ordenado NOT BETWEEN 100000 AND 200000; 45

45
 Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

DML Comando SELECT

Os resultados podem ser combinados por intermédio
dos conetores lógicos AND ou &&, OR ou ||, e NOT ou !

• Exemplo: listar número de contas da agência Horta com

balanço superior a 100
SELECT account_number
FROM account
WHERE branch_name = ‘ Horta’ AND balance > 100

• Exemplo: listar Nome, Ordenado e Cargo de empregados com

ordenado entre 100 mil e 200 mil e que tenham o cargo de secretário
SELECT Nome, Ordenado, Cargo
FROM Empregado
WHERE Ordenado BETWEEN 100000 AND 200000
AND Cargo='Secretário’;

26/05/2020 46

46

Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

DML Comando SELECT com agregação

• Na linguagem SQL é possível obter resultados que agregam (resumem)
grupos de linhas.
• O comando GROUP BY é utilizado para dividir as linhas de uma tabela
em grupos mais pequenos.
• Algumas das funções (estatísticas) de grupo são:
AVG(<expr_numérica>) valor médio
COUNT(<expr>) número de vezes que a
expr toma um valor
MAX(<expr>) valor máximo de expr
MIN(<expr>) valor mínimo de expr
SUM (<expr_numérica>) soma dos valores
• expr indica argumentos que podem ser do tipo CHAR, NUMBER ou DATE.
• Todas as funções de grupo, à exceção de COUNT(*), ignoram os valores nulos.
• As funções de grupo tratam todas as linhas de uma tabela como um grupo.
26/05/2020 47

47
 Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

DML Comando SELECT com agregação

• Exemplo: Cálculo da média dos ordenados de todos os empregados:
SELECT AVG(Ordenado)
FROM Empregado;
• Exemplo: Determinar o saldo médio das contas na agência Perryridge.
SELECT AVG (balance)
FROM account
WHERE branch_name = ‘Perryridge’;
• Exemplo: Calcular o número de clientes.
SELECT COUNT (*)
FROM customer;
• Exemplo: Encontrar o número de depositantes do banco.
SELECT COUNT (DISTINCT customer_name)
FROM depositos;
• Exemplo: Encontrar o menor ordenado dos secretários.
SELECT MIN(Ordenado) FROM Empregado
WHERE Cargo='secretario';
26/05/2020 48

48

Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

SELECT com agregação e GROUP BY

• Exemplo: Calcular a média de ordenados por cargo dos
empregados:
SELECT Cargo, AVG(Ordenado) AS ‘MédiaDeOrdenado’
FROM Empregado
GROUP BY Cargo;
• Exemplo: Calcular a média de ordenados por cargo e
departamento dos empregados ordenado por departamento:
SELECT Cargo, Cod_Depar, AVG(Ordenado) AS “MédiaDeOrdenado”
FROM Empregado
GROUP BY Cod_Depar, Cargo
ORDER BY Cod_Depar;
Podem usar-se números de ordem, usando a ordem no SELECT,
para identificar as colunas em GROUP BY ou ORDER BY
Exemplo: equivalente à consulta anterior:
GROUP BY 2, 1
ORDER BY 2; 49
26/05/2020

49
 Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

DML Comando SELECT com agregação

• Exemplo: porque dá este exemplo erro?
SELECT idNome, endereco, MAX(codigoPostal)
Se um cliente tiver várias
FROM Morada
moradas, qual escolher
GROUP BY idNome;
para a tabela resultado?
ERROR 1055 (42000): Expression #2 of SELECT list is not in GROUP BY clause and
contains nonaggregated column 'mydb.morada.endereco' which is not functionally dependent
on columns in GROUP BY clause; this is incompatible with sql_mode=only_full_group_by

• O engine mydb do MySQL, por defeito, não dá erro

sendo a coluna ocupada com o primeiro valor
identificado, o que pode levar a interpretações erradas
no caso de relações 1:n entre os atributos.
• Para evitar este comportamento, usar:
SET sql_mode = 'ONLY_FULL_GROUP_BY';

26/05/2020 50

50

Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

DML Comando SELECT com agregação

Atributos na clausula SELECT fora das funções de
agregação têm de aparecer na lista GROUP BY
ou ter com as que aparecem uma relação
funcional do tipo 1:1.
• Exemplo: corrigindo o exemplo anterior.
SELECT idNome, endereco, MAX(codigoPostal)
FROM Morada +-------------------------------------------+
GROUP BY idNome, endereco; | idNome | endereço | MAX(cd )|
+-------------------------------------------+
ou | 12 | Rua A | 1200 |
SELECT idNome, MAX(codigoPostal) | 12 | Rua B | 1521 |
| 15 | Rua A | 1200 |
FROM Morada +-------------------------------------------+
GROUP BY idNome;
Se aparecer mais do que um atributo em GROUP
BY, então cada grupo é formado pelos tuplo
com valores iguais em todos os atributos

26/05/2020 51

51
 Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

DML Comando SELECT com agregação

• Usar a cláusula HAVING para selecionar linhas numa tabela
resultante de uma função de agregação.
• As condições na cláusula HAVING são aplicadas depois da
formação dos grupos, enquanto que as condições na cláusula
WHERE são aplicados antes da formação dos grupos.
• Exemplo: Listar os ordenados máximos por cargo de
empregado, se superiores a 300 mil:
SELECT Cargo, MAX(Ordenado) AS MaxDeOrdenado
FROM Empregado
Não funciona no
GROUP BY Cargo
MySQL, tem-se de
HAVING MaxDeOrdenado >= 300000;
usar a fórmula
• Exemplo: listar os nomes de todas as agências cujo valor
médio dos saldos das contas é superior a 1 200.
SELECT branch_name, AVG (balance) FROM account
WHERE balaco <> 0 Pode-se combinar
GROUP BY branch_name having e where no
26/05/2020 HAVING AVG (balance) > 1200 mesmo comando 52

52

Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

Testes a Null
• As linhas podem conter valores nulos, denotados por NULL,
nalguns dos seus atributos.
• NULL significa um valor não preenchido, ou que não existe.
• O predicado IS NULL pode ser utilizado para testar a existência de
valores nulos.
• Exemplo: mostrar todos os números de empréstimos
com um valor nulo na coluna amount.
SELECT loan_number FROM loan
WHERE amount IS NULL
• O resultado de uma expressão aritmética com NULL é NULL
• Exemplo: 5 + NULL devolve NULL
• As funções de agregação ignoram os NULL à exceção de COUNT(*):
• Exemplo: calcule o total de todos os montantes dos empréstimos
SELECT SUM (amount)
FROM loan
• A instrução acima ignora montantes NULL;
• Resultado é NULL se não existir nenhum montante não-NULL.
26/05/2020 53

53
 Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

Valores Null e Lógica Trivalente

• Qualquer comparação com NULL retorna UNKNOWN
Exemplo: 5 < NULL ou NULL <> NULL ou NULL = NULL
• Lógica trivalente usando o valor lógico unknown:
• OR: (unknown OR true) = true,
(unknown OR false) = unknown
(unknown OR unknown) = unknown
• AND: (true AND unknown) = unknown,
(false AND unknown) = false,
(unknown AND unknown) = unknown
• NOT: (NOT unknown) = unknown
• “P IS unknown” é verdade se o valor de P é unknown.
• O resultado da condição da cláusula WHERE ou
HAVING é tratado como FALSE quando o seu valor é
UNKNOWN
26/05/2020 54

54

Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

Operações de Junção
• As operações de junção retornam uma relação como resultado
da combinação de duas outras relações.
• Estas operações são utilizadas na cláusula FROM em SELECT,
UPDATE e DELETE para cruzar tabelas do MySQL.
• A condição de junção define quais as linhas que são combinadas
nas duas relações, assim como os atributos que funcionam como
chave primária (de uma tabela) e chave estrangeira (na outra).
• O tipo de junção define como tratar as linhas que não têm
correspondência nas chaves.

Tipos de Junção Condições de Junção

[INNER] JOIN NATURAL
LEFT [OUTER] JOIN ON (PK=FK)
RIGHT [OUTER] JOIN USING (PK)
FULL [OUTER] JOIN

Nota: No MySQL o JOIN, CROSS JOIN e INNER JOIN são equivalentes. No SQL standard não
são. O INNER JOIN é usado com a condição ON, o CROSS JOIN é usado nos outros casos.
26/05/2020 55

55
 Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

Operações de Junção

26/05/2020 56

56

Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

Operações de Junção
Clausulas exclusivas do MySQL:

• NATURAL JOIN
Identifica como chaves os campos nas duas tabelas que têm
igual identificador;
Dá resultados sem repetição de colunas;
Desaconselhado, pode não identificar as chaves corretamente,
dá problemas com chaves compostas.

• JOIN ... USING

Usado quando a chave estrangeira tem o mesmo nome da
primária;
Não é desaconselhado já que a chave é explicitada, tal como
em ON.
• FULL JOIN não está implementado
26/05/2020 57

57
 Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

Junção versus Produto Cartesiano

A cláusula FROM corresponde à operação de produto cartesiano da
álgebra relacional. A relações a consultar na avaliação da expressão
é o produto cartesiano das duas (ou mais) relações enumeradas.
• Exemplo: listar o nome, número de aluno e identificação
da turma de todos os alunos com mais de seis anos.
SELECT aluno.nome, aluno.nAluno, turma.idTurma
FROM aluno, turma
WHERE aluno.idTurma = turma.idTurma
AND aluno.anoNasc<YEAR(CURRENT_DATE)-6
• Versus:
SELECT aluno.nome, aluno.nAluno, turma.idTurma
FROM aluno INNER JOIN turma USING (idTurma)
WHERE aluno.anoNasc<YEAR(CURRENT_DATE)-6
A última separa claramente a formação da nova tabela sobre
a qual se colocam as condições “de filtragem” (seleção)
Esta separação torna a leitura mais fácil.
26/05/2020 58

58

Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

Exemplos de operações de Junção

Dados para os exemplos:
• Relação emprestimo
loan_number branch_name amount
L-170 Downtown 3000
L-230 Redwood 4000
L-260 Perryridge 1700
Sem correspondência
• Relação cliente
customer_name loan_number

Jones L-170
Smith L-230
Hayes L-155 Sem correspondência

26/05/2020 59

59
 Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

Exemplos de operações de Junção

emprestimo INNER JOIN
cliente USING (loan_number)
loan_number branch_name amount customer_name loan_number

L-170 Downtown 3000 Jones L-170

L-230 Redwood 4000 Smith L-230

emprestimo LEFT OUTER JOIN

cliente ON (emprestimo.loan_number = cliente.loan_number)

loan_number branch_name amount customer_name loan_number

L-170 Downtown 3000 Jones L-170
L-230 Redwood 4000 Smith L-230
L-260 Perryridge 1700 null null

26/05/2020 60

60

Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

Exemplos de operações de Junção

emprestimo NATURAL JOIN cliente

loan_number branch_name amount customer_name

L-170 Downtown 3000 Jones

L-230 Redwood 4000 Smith

emprestimo NATURAL RIGHT OUTER JOIN cliente

loan_number branch_name amount customer_name

L-170 Downtown 3000 Jones
L-230 Redwood 4000 Smith
L-155 null null Hayes

26/05/2020 61

61
 Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

Exemplos de operações de Junção

emprestimo FULL JOIN cliente USING (loan_number)

loan_number branch_name amount customer_name

L-170 Downtown 3000 Jones

L-230 Redwood 4000 Smith
L-260 Perryridge 1700 null
L-155 null null Hayes

Listar todos os clientes que não têm, em simultâneo, uma

conta e um empréstimo no banco (mas não ambos!)

SELECT DISTINCT cliente.customer_name

FROM emprestimo FULL JOIN cliente USING (loan_number)
WHERE emprestimo.branch_name IS NULL Os OUTER JOIN servem
OR cliente.customer_name IS NULL para testes à inexistência
de relações entre tabelas
26/05/2020 62

62

Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

A operação de Renomeação
• A linguagem SQL permite a renomeação de relações e atributos
recorrendo à cláusula AS :
<old_name> AS <new_name>

• Listar o nome, número de empréstimo e montante de todos os

clientes, renomeando o nome da coluna loan_number para loan_id.

SELECT customer_name, borrower.loan_number AS loan_id, amount

FROM borrower
INNER JOIN loan ON (borrower.loan_number = loan.loan_number);

• Caso se pretenda utilizar um nome com espaços, esse nome

deverá ser colocado entre aspas simples ou duplas.
26/05/2020 63

63
 Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

Variáveis de tuplo
No Oracle10g
• As variáveis de tuplo são definidas na cláusula não usar AS
FROM por intermédio da cláusula AS opcional. apenas espaço
• Apresente os nomes de todos os clientes e respectivos números dos
empréstimos que possuam um empréstimo numa qualquer agência.

SELECT customer_name, T.loan_number, S.amount

FROM borrower AS T
INNER JOIN loan AS S ON (T.loan_number = S.loan_number);

• Liste todas as agências que têm mais ativos do

que pelo menos uma agência localizada em Brooklyn:
SELECT DISTINCT T.branch_name
FROM branch AS T, branch AS S
WHERE T.assets > S.assets AND S.branch_city = ‘Brooklyn’

26/05/2020 64

64

Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

Variáveis de tuplo
• As variáveis de tuplo podem ser vistas como criando várias
cópias de uma mesma relação (similar às renomeações da A.R.)
• Exemplo: Considere a relação:
VOOS (numVoo, Matricula, Data, Hora, De, Para)
em que cada tuplo denota um voo com numVoo, efectuado do
aeroporto De para o aeroporto Para no dia Data à hora Hora no avião
com Matrícula.
• Consulta: Quais os pares de voos que usaram o mesmo avião num
mesmo dia?
SELECT DISTINCT T.numVoo, S.numVoo
FROM voos AS T
INNER JOIN voos AS S USING (Matricula)
WHERE T.Data = S.Data
AND T.numVoo < S.numVoo
Necessário porque dá todas
as combinações possíveis
26/05/2020 (pares ordenados) 65

65
 Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

Consultas imbricadas ou Subconsultas

• SQL disponibiliza um mecanismo para aninhar (imbricar)
consultas umas dentro de outras.
• Uma subconsulta é uma expressão SELECT-FROM-WHERE
que se encontra dentro de uma outra (sub)consulta.
• Subconsultas na clausula FROM são entendidas como
cálculo de relações auxiliares.
• As subconsultas na clausula WHERE são utilizadas para
efetuar testes de pertença a conjuntos, comparações entre
conjuntos ou cálculo da cardinalidade de conjuntos.

• Exemplo: listar todos os alunos com turma atribuída.

SELECT DISTINCT aluno.nome Seria fácil de fazer com um
FROM aluno JOIN entre as duas tabelas
WHERE aluno.idTurma IN (SELECT turma.idTurma FROM turma)

• Exemplo: listar todos os alunos com registo na tabela

26/05/2020 aluno mas sem turma atribuída. 66

66

Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

aluno turma escola

nAluno
|| | | nomeEsc
|< <
nome identificacao
anoNascimento diretorTurma campanha
<

habitacao distância

morada
tipoHabitacao

ALUNO (nAluno, morada, nome, anoNascimento, identificacao)

HABITAÇÃO (morada, tipoHabitação)
ESCOLA (nome, campanha)
PROXIMIDADE (nomEsc, morada, distância)
TURMA (identificacao, nAlunos, nomEsc)
26/05/2020 67

67
 Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

Consultas imbricadas ou Subconsultas

• Exemplo: listar todos os alunos que têm um registo na tabela
aluno e turma atribuída com habitação a menos de 600 m da
escola.

SELECT DISTINCT aluno.nome

FROM aluno JOIN turma USING (idTurma)
WHERE turma.nomEsc IN
(SELECT escola.nomEsc
FROM escola JOIN proximidade USING (nomEsc)
WHERE proximidade.distancia<= 600)

• Nota: A consulta acima pode ser escrita de uma maneira

muito simples usando JOINS. A formulação utilizada serve
apenas para ilustrar as possibilidades da linguagem SQL.

26/05/2020 68

68

Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

Teste sobre Conjuntos

A construção EXISTS devolve o valor TRUE se a subconsulta
é não vazia. Muitas vezes usado para verificar a existência
mesmo que
duma relação entre tabelas. seja tudo NULL
• EXISTS (<consulta>) TRUE se a consulta não for vazia
• NOT EXISTS (<consulta>) TRUE se a consulta for vazia
• Operações de pertence ou não pertence a conjunto
• IN, NOT IN (<lista>|<consulta>)

Operações de conjuntos em conjuntos:

=ANY ou =SOME é
• Quantificadores existencial e universal o mesmo que IN
• <operador comparação> {SOME | ANY} (<consulta>)
TRUE se é verdade para pelo menos um dos valores da consulta
<>ALL é o mesmo
• <operador comparação> ALL (<consulta>) que NOT IN
TRUE se a comparação é verdade para todos os valores da consulta
• TRUE se não tem linhas duplicadas: UNIQUE (<consulta>)
26/05/2020 69

69
 Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

Consultas imbricadas com EXISTS

Que tipos de habitação têm pelo menos um aluno
inscrito na turma A?
SELECT DISTINCT tipoHabitacao
FROM habitacao
WHERE EXISTS ( Bastaria fazer um
SELECT * FROM aluno INNER JOIN de tudo
INNER JOIN turma USING (identificacao)
WHERE habitacao.morada=aluno.morada
AND turma.identificação=“A”);

Que tipos de habitação não têm nenhum aluno

inscrito numa turma da escola ES PDl?
SELECT DISTINCT tipoHabitacao
Bastaria habitacao
FROM habitacao
LEFT JOIN escola …
WHERE NOT EXISTS (
SELECT * FROM aluno
INNER JOIN turma USING (identificacao)
WHERE habitacao.morada=aluno.morada
AND turma.nomEsc=“ES PDl”);
26/05/2020 70

70

Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

Consultas imbricadas com ANY e ALL

Identificar a turma com o aluno mais velho da

escola ES PDl.
Ou MIN(datNasc)
SELECT turma.*
FROM turma INNER JOIN aluno USING (identificacao)
WHERE aluno.dataNasc < ALL (
SELECT aluno.dataNasc
FROM aluno
INNER JOIN turma USING (identificacao)
WHERE turma.nomEsc = “ES PDl”);

26/05/2020 71

71
 Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

Consultas imbricadas com UNIQUE

A construção UNIQUE testa se uma subconsulta tem linhas
duplicadas.
• Exemplo: Encontrar todos as habitações que têm só um aluno
da escola EB23 Arrifes.
SELECT h.morada
seria mais fácil
FROM habitacao AS h
com um count()
WHERE UNIQUE (
SELECT p.morada
FROM habitação
JOIN proximidade AS p USING (morada)
WHERE p.nomEsc= ‘EB23 Arrifes’)

A construção NOT UNIQUE verifica se o resultado de uma

subconsulta possui pelo menos duas linhas duplicadas.
• Exemplo: Encontrar todos as habitações que têm pelo
menos dois alunos na escola EB23 Arrifes.
26/05/2020 72

72

Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

Relações Derivadas
• Determinar o saldo médio por conta em agências cujo saldo
médio é superior a 1 200.
SELECT account_name, AVG(balance)
FROM (
SELECT branch_name, AVG (balance) AS avg_balance
FROM account
GROUP BY branch_name
HAVING AVG (balance) > 1200
) AS a
INNER JOIN account USING (branch_name)
GROUP BY account_name;

Repare que, dado que é calculada uma relação temporária na

cláusula FROM, os atributos dessa relação podem ser utilizados
diretamente no SELECT exterior .

26/05/2020 73

73
 Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

Cláusula With
• A cláusula WITH permite a definição local de vistas relativas a
uma consulta, em vez de globalmente. Análogo a
procedimentos locais de uma linguagem imperativa.
• Já implementado no MySQL versão 8.0 com a designação
common table expressions.

Exemplo: Encontrar as contas de maior saldo

WITH max_balance(value) AS (
SELECT max (balance)
FROM account
)
SELECT account_number
FROM account AS a
INNER JOIN max_balance AS mb ON (a.balance = mb.value);
26/05/2020 74

74

Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

Exemplo com WITH

• Exemplo: Quais as agências cuja soma de saldos das suas contas
são superiores à media da soma dos saldos de todas as agências.

WITH branch_total (branch_name, value) AS (

SELECT branch_name, SUM(balance)
FROM account
GROUP BY branch_name)

WITH branch_total_avg(value) AS (
SELECT AVG (value)
FROM branch_total )

SELECT branch_name
FROM branch_total, branch_total_avg
WHERE branch_total.value >= branch_total_avg.value;
26/05/2020 75

75
 Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

Operações com Conjuntos

• As operações com conjuntos UNION, INTERSECT, e
EXCEPT operam sobre tabelas e correspondem aos
operadores de conjuntos   −
• INTERSECT, e EXCEPT não estão implementados no
MySQL.
• Cada uma das operações anteriores elimina os
duplicados automaticamente. Para reter duplicados
deve-se utilizar as respectivas versões multiconjunto
UNION ALL, INTERSECT ALL e EXCEPT ALL.
• Suponha que uma linha ocorre m vezes em r e n
vezes em s, então ele ocorre:
• m+n vezes em r UNION ALL s
• min(m,n) vezes em r INTERSECT ALL s
• max(0, m–n) vezes em r EXCEPT ALL s
26/05/2020 76

76

Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

Exemplos de Operações com Conjuntos

• Exemplo: Listar todas as moradas, tenham ou não um aluno numa escola:
(SELECT habitacao.morada FROM habitacao)
UNION UNION ALL permite linhas
(SELECT aluno.morada FROM aluno) repetidas no resultado

• Exemplo: Todas as moradas com registo na tabela habitação e na tabela aluno:

(SELECT habitacao.morada FROM habitacao)
INTERSECT
(SELECT aluno.morada FROM aluno)

• Exemplo: Listar as moradas que não têm alunos numa das escolas da BDs:
(SELECT habitacao.morada FROM habitacao)
EXCEPT
(SELECT aluno.morada FROM aluno)

26/05/2020 77

77
 Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

Exemplos de Operações com Conjuntos

• Exemplo:

Obter as duas cidades com o nome mais longo e

mais curto e o respetivo número de caracteres:

(SELECT city, MAX(LENGTH(city)) AS comp

FROM station)
UNION
(SELECT city, MIN(LENGTH(city)) AS comp
FROM station);

26/05/2020 78

78

Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

Como obter o EXCEPT

• Exemplo:

Obter os nomes de clientes que são depositores

mas não emprestadores:
SELECT d.nomeCli
FROM (
( SELECT nomeCli
FROM depositor
INNER JOIN cliente USING (idCli)
) AS d
RIGHT JOIN (
( SELECT nomeCli
FROM emprestador
INNER JOIN cliente USING (idCli)
) AS e
WHERE d.nomeCli IS NULL);
26/05/2020 79

79
 Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

Vistas (VIEWS)
• Em certas circunstâncias, não é desejável que todos os utilizadores
possam aceder a todo o modelo lógico (i.e. a todas as relações
armazenadas na base de dados)
• Considere o caso de um empregado que necessita de saber o
número e tipo de habitação de um aluno, mas não precisa de saber
a morada. Este empregado deverá ver apenas a tabela:
SELECT aluno.nAluno, habitacao.tipoHabit
FROM aluno JOIN habitacao USING (morada)
• Qualquer relação que não pertença ao modelo conceptual mas que
se torne visível ao utilizador como uma “tabela virtual” é designada
por vista (ou view).
• Uma View funciona como uma janela, fornecendo uma perspectiva
única da BDs, sem que haja uma existência física na BD - é como
uma tabela virtual.
• Depois de criada uma View, os dados que ela apresenta não lhe
pertencem, pertencem às tabelas onde foram introduzidos. Por isso,
qualquer alteração nos dados de uma tabela reflecte-se nos dados
das Views a ela associados. 80
26/05/2020

80

Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

Razões para se Optar por “Vistas”

• Por questões de segurança;
• Por questões de confidencialidade;
• Simplicidade, permitem uma
programação mais estruturada;
• Um comando SELECT simples realizado
sobre a View é equivalente a uma
consulta imbricada;
• As Views reforçam a independência dos
dados das aplicações a que se destinam
26/05/2020 81

81
 Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

Vistas (VIEWS)
Para criar uma vista utilizamos o comando:
CREATE VIEW <nome da vista> [(<atributo>,<atributo>, …)]
AS <query expression>
• onde a <query expression> pode envolver tabelas ou outras views.
• as views por não serem tabelas físicas, não podem ter índices.
• as views são alternativas às tabelas pelo que são comandos DDL.
• Usa-se DROP VIEW para eliminar uma view, tal como para as tabelas.
• Exemplo: criar uma vista para os bons fornecedores:
CREATE VIEW Bons_Fornecedores AS
SELECT fId, estatuto, cidade
FROM fornecedor
WHERE estatuto = ‘bom;
• Exemplo: criar uma vista para os fornecedores com produtos topo de gama:
CREATE VIEW ‘topo de gama’ (codProd, desigacao) AS
SELECT codProd, designacao, preco
FROM produtos
WHERE preco > 10000;
26/05/2020 82

82

Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

Definição de vistas
• Uma definição de uma vista não é o mesmo que a criação
duma nova tabela a partir da avaliação da sua expressão.
Em vez disso, a definição da vista permite usar a expressão
nas consultas que utilizam a vista.
• Uma vista pode ser utilizada na expressão de definição de
outra vista.
• Uma vista v1 depende directamente de uma vista v2 se v2 é
utilizada na expressão que define v1
• Uma vista v1 depende de uma vista v2 se v1 depende
directamente de v2 ou se existe um caminho de
dependências entre v1 e v2
• Uma vista v diz-se recursiva se depender dela própria.
• Em SQL não são permitidas vistas recursivas!
26/05/2020 83

83
 Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

Exemplo:
• Exemplo: Uma vista contendo todas as moradas da BDs
CREATE VIEW todasMoradas (morada) AS
(SELECT aluno.morada
Para renovar uma view sem
FROM aluno)
apagar usar:
UNION
CREATE OR REPLACE VIEW
(SELECT habitacao.morada
FROM habitacao)

• Exemplo: Listar todas as moradas nos arrifes

SELECT morada
FROM todasMoradas
WHERE morada LIKE ‘%arrifes%’
Deste modo as views tal como o WITH podem ser usadas para
simplificar consultas complexas, mas mantendo a tabela virtual
depois de terminar de executar a instrução.
26/05/2020 84

84

Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

Outros Comandos DML – DELETE

• A remoção de linhas de uma tabela (ou vista) é
feita em SQL com a instrução

DELETE FROM <tabela ou vista>

WHERE <condição>

• Exemplo: Apagar todas as contas da agência

de Perryridge

DELETE FROM account

WHERE branch-name = ‘Perryridge’

26/05/2020 85

85
 Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

Exemplo de DELETE
• Exemplo: Apagar todas os depositores com contas de todas as
agências na cidade de Needham.
Normalmente não é possível
DELETE FROM depositor
WHERE account-number IN ( usar JOINs logo as condições
sobre conjuntos são importantes
SELECT account-number
FROM branch NATURAL JOIN account
WHERE branch-city = ‘Needham’
);

• Exemplo: Apagar as próprias contas de todas as agências na

cidade de Needham.
DELETE FROM account
WHERE branch-name IN (
SELECT branch-name
FROM branch
WHERE branch-city = ‘Needham’
);
26/05/2020 86

86

Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

Remoção em múltiplas tabelas

É possível a remoção em junções de tabelas desde que seja mantida uma
relação um para um com as tabelas originais, donde efetivametne se vão
apagar as linhas.

DELETE
FROM <tabela ou vista>
JOIN <tabela ou vista> ...
{ USING (<nome_coluna>) | ON (<tab1.col1> = <tab2.col2>) }
WHERE <tabela ou vista>
;

Consultas muito complexas podem ter ambiguidades sobre qual a linha da

tabela base se refere, nesse caso o comando não funciona.
26/05/2020 87

87
 Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

DELETE com condições que

dependem da tabela a ser apagada
• Exemplo: Remover todas as contas com saldos
inferiores aos da média do banco.
DELETE FROM account
WHERE balance < SOME (
SELECT AVG (balance)
FROM account)
• Problema: à medida que removemos linhas de account,
o saldo médio altera-se;
• Solução utilizada no standard SQL:
1. Primeiro, calcula-se o saldo médio (AVG) e determinam-
se quais as linhas a apagar;
2. Seguidamente, removem-se todos as linhas identificadas
anteriormente (sem recalcular AVG ou testar novamente)
26/05/2020 88

88

Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

Outros Comandos DML – INSERT

• A inserção de linhas numa tabela (ou vista)
é feita em SQL com a instrução:
INSERT INTO <tabela ou vista> [(<atributo>, <atributo>, …)]
[VALUES | VALUE] [(<valor>, <valor>, …) | VIEW | SELECT]
• Adicionar uma nova linha a account
INSERT INTO account
VALUES (‘A-9732’, ‘Perryridge’,1200)

ou equivalentemente:
INSERT INTO account (branch-name, balance, account-number)
VALUES (‘Perryridge’, 1200, ‘A-9732’)

• Adicionar uma nova linha a account em que balance é null

INSERT INTO account
VALUES (‘A-777’,‘Perryridge’, null)
26/05/2020 89

89
 Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

INSERT de dados de outra tabela

• Sintaxe com SELECT permite operações mais complexas
INSERT INTO <tabela ou vista> [<atributo>, <atributo>, …]
SELECT <atrib1>, <atrib2>, …
FROM {<tabela> | <vista> | <junção de tabelas ou vistas> }
WHERE …
• Adicionar um questionário dum cliente identificado por NIF:
INSERT INTO questionário (cliente_idCliente, correio_informativo,
valor_mes, marca_preferida)
SELECT cliente.idCliente, 1, 4, "ACERTA“
FROM cliente
WHERE cliente.NIF=654615;

26/05/2020 90

90

Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

Exemplo de Inserção
• Exemplo: Dar como bónus a todos os mutuários da agência
de Perryride, uma conta de poupança de 200. O número do
empréstimo servirá de número de conta de poupança
INSERT INTO account
SELECT loanNumber, branchName, 200
FROM loan
WHERE branchName = ‘Perryridge’;
INSERT INTO depositor
SELECT customerName, loanNumber
FROM loan NATURAL JOIN borrower
WHERE branchName = ‘Perryridge’;

• Exemplo: A instrução SELECT-FROM-WHERE é avaliada

previamente à inserção de linhas na relação (caso contrário
consultas como
INSERT INTO table1 SELECT * FROM table1
causariam problemas)
26/05/2020 91

91
 Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

Modificação da base de dados – UPDATE

• A actualização de linhas duma tabela (ou vista)
é feita em SQL com a instrução:
UPDATE <tabela ou vista>
SET <Atributo> = <Expressão>, <Atributo> = <Expressão>, ...
[WHERE <Condição>]

• Pagar juros de 1% a todas as contas da agência Perryride.

UPDATE account
SET balance = balance  1.01
WHERE branch_name = ‘Perryridge’

26/05/2020 92

92

Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

Modificação da base de dados – Atualização

• Pagar juros de 6% a todas as contas com saldos
superiores a 10 000, e juros de 5% às restantes contas.

• Exemplo: Escrever duas instruções de UPDATE:

UPDATE conta
SET saldo = saldo  1.06
WHERE saldo > 10000;

UPDATE account
SET saldo = saldo  1.05
WHERE saldo =< 10000;

• A ordem é importante.

26/05/2020 93

93
 Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

Atualização de uma Vista

Modificações nas bases de dados através de vistas são traduzidas
para modificações nas tabelas em que se baseia a vista.

• E.g.: com uma vista com a informação sobre empréstimos,

escondendo o atributo amount
CREATE VIEW branch-loan AS
SELECT branch-name, loan-number
FROM loan

• a adição de uma nova linha a branch-loan

INSERT INTO branch-loan
VALUES (‘Perryridge’, ‘L-307’)

• deve ser traduzida na inserção na relação loan da linha

(‘L-307’, ‘Perryridge’, null)
26/05/2020 94

94

Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

Actualização de uma Vista

Algumas atualizações através de vistas são impossíveis de traduzir
para actualizações das tabelas base
• Exemplo: considere a vista
CREATE VIEW v1 AS
SELECT * FROM loan
WHERE branch-name = ‘Perryridge’
• A seguinte adição é impossível
INSERT INTO v1
VALUES (‘L-307’,‘Downtown’,1000)
Outras não têm tradução única:
• Exemplo: considere a vista
CREATE VIEW all_costumers AS (
SELECT * FROM depositor)
UNION (SELECT * FROM borrower)
• Toda a adição em all_costumers não tem tradução única:
Deve introduzir-se em depositor ou em borrower???

Face a isto, o SQL opta por restringir aquilo que é permitido. A

maioria das implementações SQL permite apenas a actualização de
vistas simples (sem agregações) definidas sobre uma única relação.

26/05/2020 95

95
 Structured Query Language Armando B. Mendes e Elisabete Freire, FCT-UAc

Condições para Atualização de uma Vista

Apenas é possível introduzir novas linhas, fazer atualizações de dados ou
apagar dados se existir uma relação 1:1 entre as linhas da vista e as linhas
da(s) tabela(s) base.
Estas instruções não permitem a inserção ou atualização de uma vista:
• Funções de agregação SUM(), MIN(), MAX(), COUNT(), AVG(), …
• DISTINCT
• GROUP BY
• HAVING
• UNION or UNION ALL
• subqueries independentes inseridas num SELECT falham num INSERT, mas
podem ser usadas para UPDATE e DELETE. Subqueries com dependências
não permitem qualquer das instruções de alteração de dados.
• Alguns JOIN;
• FROM com views que não são atualizáveis.
• Subqueries em WHERE que se referem a tabelas em FROM
• Se o resultado da query for literais (neste caso não há nada para atualizar)
• Uso de tabelas temporárias;
• Multiplas referencias a qualquer coluna da tabela base (falha apenas em
INSERT, funciona para UPDATE, DELETE)
26/05/2020 96

96