Laboratório de Banco de Dados

Introdução ao PostgreSQL

Profs. Valéria Gonçalves Soares

Mateus Fernandes Cunha

DIMAp/UFRN
Conteúdo
Introdução ao PostgreSQL
Conceitos Básicos
Acessando o Banco de Dados
Linguagem SQL
Definição de Dados
Manipulação de Dados
Consulta aos Dados
Funções e Operadores
Gatilhos e Procedimentos
Administração da Base de Dados
Conceitos Básicos
Desenvolvimento de Aplicativos
Objetivo da Disciplina
Oferecer aos alunos condições de trabalhar
com um Banco de Dados Relacional, deixando-os
aptos a:
Criar uma Base de Dados;
Manipular a Base de Dados;
Consultar a Base de Dados.
Oferecer subsídios ao desenvolvimento de um
aplicativo que acesse o banco de dados e
disponibilize todas as funcionalidades básicas
requeridas de um sistema de BD.
Introdução ao PostgreSQL
Embora o PostgreSQL seja um sistema
gerenciador de banco de dados objeto-
relacional, nesta disciplina iremos abordar
apenas os aspectos relacionais do mesmo.
O PosgreSQL é baseado no POSGRES que foi
pioneiro em muitos conceitos que se tornaram
disponíveis posteriormente em muitos
sistemas de bancos de dados comerciais.
O PosgreSQL é open-source e suporta tanto
o SQL92 como o SQL99, além de oferecer
muitas características modernas, tais como:
 Introdução ao PostgreSQL
Características PostgreSQL: PostgreSQL pode ser
Consultas complexas estendido pelo usuário de
Chaves estrangeiras muitas maneiras, por
exemplo, pela adição de
Gatilhos
novos:
Visões
Tipos de dados
Integridade transacional
Funções
Controle de concorrência
Operadores
multiversão
Funções de Agregação
Métodos de Indexação
Linguagens Procedurais
Arquitetura PostgreSQL
O PostgreSQL usa um modelo cliente/servidor. Uma
sessão PostgreSQL consiste dos seguintes programas
que cooperam entre si:
Um processo servidor que gerencia os arquivos de bancos de
dados, aceita as conexões ao banco a partir das aplicações
clientes, e executa ações no banco de dados solicitadas pelos
clientes. O programa servidor de banco de dados é chamado
postmaster.
Cliente(front-end): São as aplicações que precisam acessar ao
banco:
Pode ser ferramentas gráficas, modo texto, via Web,
ferramentas de manutenção e gerenciamento de banco,
ferramentas de programação de triggers e procedures, ou
qualquer outra ferramenta que precise interagir com o
PostgreSQL.
A comunicação entre Cliente e Servidor é feita via TCP/IP.
Arquitetura PostgreSQL
O servidor PostgreSQL pode gerenciar
múltiplas conexões de clientes de modo
concorrente.
Para cada conexão, o servidor inicia um novo
processo servidor para a comunicação com o
cliente (“fork”).
A comunicação entre o servidor e o cliente é
feita sem intervenção do postmaster.
Quando o postmaster recebe um novo pedido de
conexão, ele cria um novo fork que fará a
comunicação entre o cliente e o servidor
PostgreSQL.
Primeiros Passos
Para acessar o PostgreSQL dentro do DIMAp
inicialmente precisa-se acessar a máquina louco
servidora do bd:
ssh nome_da_maquina ou ssh (ip da maquina)
Ou direto, através do psql:
psql meubanco –U nomeusuario –h
nome_da_maquina
 Criando um Banco de Dados
Um servidor PostgreSQL pode gerenciar vários bancos.
Normalmente, um banco separado é usado para cada usuário ou
projeto. Para criar um novo banco de dados, que neste exemplo,
estamos chamando de meubanco utiliza-se o seguinte comando:
$ createdb meubanco
Que irá produzir a seguinte resposta:
CREATE DATABASE
Um nome de banco de dados deverá ter um primeiro caractere
alfabético e são limitados a 63 caracteres no máximo. Pode-se
também criar um banco de dados com o mesmo nome no usuário
corrente. Para isso basta digitar:
$ createdb
Para remover um banco de dados, se você for o dono do mesmo,
basta digitar:
$ dropdb meubanco
Acessando um Banco de Dados

Um Banco de Dados pode ser acessado por

diversas maneiras:
1. Terminal interativo do PostgreSQL (psql);
2.Ferramentas gráficas para a criação,
administração e manipulação de bancos
(pgAdmin);
3.Aplicações desenvolvidas pelos usuários
utilizando conexões via ODBC ou JDBC.
Acessando o Banco de Dados

O psql permite ao usuário entrar, editar e executar

interativamente comandos SQL

$ psql meubanco

Welcome to psql 7.4.1, the PostgreSQL interactive terminal.

Type: \copyright for distribution terms

\h for help with SQL commands
\? for help on internal slash commands
\g or terminate with semicolon to execute query
\q to quit

treino=#
Acessando o Banco de Dados
Verificando a versão do PostgreSQL:
$ SELECT version();

Help:
\h
Sair do psql:
\q
Comandos Básicos psql
Pode-se criar um arquivo texto com todas as
operações de criação de tabelas e de consultas,
e posteriormente executa-lo da seguinte forma:
\i caminho/nomedoarquivosql
Para ver a descrição da Tabela
\d nomedatabela
Para ver todas as tabelas criadas
\d
PostgreSQL

Linguagem SQL
Introdução

A Structured Query Language (SQL) permite aos

usuários acessar, definir e manipular dados em bancos de
dados relacionais, como PostgreSQL, Oracle, Sybase,
Informix, Microsoft SQL Server, MySql, entre outros.
Nos RDBMS os dados são armazenados em tabelas.
Uma tabela pode ser definida como uma coleção de linhas,
onde cada linha em uma tabela é formada pelo mesmo
conjunto de colunas.
Cada coluna deve possuir um tipo de dado especifico.
Exemplos de tipos de dados no PostgreSQL:
int, smallint, double precision, char(n), varchar(n), real,
date, time, timestamp e interval.
Comandos Básicos

DDL - Data Definition Language (Linguagem de Definição de

Dados):
CREATE TABLE
DROP TABLE
DML – Data Manipulation Language (Linguagem de Manipulação
de Dados):
SELECT
INSERT
UPDATE
DELETE
PostgreSQL

Definição de Dados
Linguagem de Definição de Dados

Criação das estruturas do banco de dados.

Criação, modificação e eliminação de tabelas.
Controle dos dados armazenados nas tabelas.
Privilégios associados a tabelas.
Definição de Tabelas
Para se criar uma nova tabela especifica-se o nome da
mesma e os nomes de seus atributos colunas com os seus
respectivos tipos.
O comando não acaba enquanto o psql não encontrar
o ponto-e-vírgula.
Espaços em branco podem ser usados livremente em
comandos SQL.
Como exemplos de tipos permitidos, o tipo varchar(80)
especifica um tipo que pode armazenar strings de até 80
caracteres no seu tamanho, o tipo int é o tipo inteiro
normal, o tipo real armazena números de ponto flutuante de
simples precisão, o tipo date armazena datas.
Criando uma Nova Tabela
CREATE TABLE
CREATE TABLE pessoa (
nome VARCHAR(20),
cpf CHAR(11)
endereco VARCHAR(30),
cidade VARCHAR(15),
estado CHAR(2),
nascimento DATE
);

Use o comando \d pessoa para verificar a estrutura da tabela.

Table "public.pessoa"
Column | Type | Modifiers
------------+-----------------------+-----------
nome | character varying(20) |
cpf | character(11) |
endereco | character varying(30) |
cidade | character varying(15) |
estado | character(2) |
nascimento | date |
Eliminando uma Tabela

Se não se desejar mais a tabela, por fim, pode-se

removê-la com o seguinte comando:

DROP TABLE tablename;

O comando DROP TABLE elimina permanentemente uma

tabela do banco de dados. Exemplo:

DROP TABLE pessoa;

Valores Default
Um coluna pode receber um valor padrão toda vez que
uma nova linha for inserida no sistema, e nenhum valor
for especificado para ela.

CREATE TABLE pessoa (

idpessoa integer,
nome text,
...
estado char(2) DEFAULT ‘NI’);
Restrições
Check Constraints;
Not-Null Constraints;
Unique Constraints;
Primary Keys;
Foreign Keys.
Check Constraints
Ao inserir ou atualizar uma coluna, o novo
valor só será aceito se satisfazer a
expressão de restrição.

CREATE TABLE pessoa (

idpessoa integer,
nome text,
...
sexo char(1)
CHECK sexo IN (‘M’, ‘F’)
);
Check Constraints

CREATE TABLE pessoa (

idpessoa integer,
nome text,
...
sexo char(1)
CONSTRAINT ck_sexo CHECK (sexo IN (‘M’, ‘F’))
);
Check Constraints

Outro Exemplo de Restrição.

CREATE TABLE produtos (

idproduto integer,
preco numeric,
desconto numeric,
CONSTRAINT ck_preco CHECK (preco > 0)
CONSTRAINT ck_desconto CHECK (desconto > 0 AND
preco > desconto)
);
Restrição Not Null
Não permite que a coluna assuma um valor nulo.

CREATE TABLE pessoa (

idpessoa integer NOT NULL,
nome text NOT NULL,
...
sexo char(1),
CHECK sexo IN (‘M’, ‘F’)
);
Restrição UNIQUE
Garante que o valor de uma coluna ou grupo de colunas é
único para todas as linhas da tabela.

CREATE TABLE pessoa (

idpessoa integer UNIQUE,
nome text);
Restrição UNIQUE: Outros Formatos

CREATE TABLE pessoa (

idpessoa integer,
nome text,
UNIQUE (idpessoa));

CREATE TABLE pessoa (

a integer,
b integer,
c integer
UNIQUE (a,b));
PRIMARY KEY (Chave Primária)

Normalmente usada como identificador único

para linhas na tabela.
Tecnicamente pode ser considerada como uma
junção das restrições Not-Null e Unique.
Uma tabela só pode ter uma única chave
primária, que pode ser simples ou composta.
CREATE TABLE pessoa (
idpessoa integer PRIMARY KEY,
nome text);
FOREIGN KEY (Chave Estrangeira)

Especifica que os valores em uma coluna ou grupo de

colunas dependem da existência em alguma linha de
outra tabela.
Mantém a integridade referencial entre as duas
tabelas.

CREATE TABLE aluno (

matricula numeric PRIMARY KEY
idpessoa integer REFERENCES pessoa(idpessoa),
ira real
);
FOREIGN KEY (Chave Estrangeira)

ON DELETE CASCADE
ON DELETE SET NULL
ON DELETE SET DEFAULT

CREATE TABLE aluno (

matricula numeric PRIMARY KEY,
idpessoa integer
REFERENCES pessoa(idpessoa) ON DELETE CASCADE,
ira real
);
Modificando Tabelas

Adicionar Colunas.
Remover Colunas.
Adicionar Restrições.
Remover Restrições.
Mudar Valor Default.
Renomear Colunas.
Renomear Tabelas.
Adicionando Uma Nova Coluna
Adiciona uma nova coluna em uma tabela existente.
ALTER TABLE pessoa ADD COLUMN email text;

A definição da restrição pode ser feita no momento da

criação da coluna, com exceção de Not-Null.

ALTER TABLE pessoa

ADD COLUMN sexo char(1)
CHECK (sexo IN (‘M’,’F’));
Removendo Uma Coluna

Também pode-se remover uma coluna de uma tabela. O

comando abaixo especificado remove uma coluna da
tabela pessoa.

ALTER TABLE pessoa DROP COLUMN email;

Adicionando Uma Nova Restrição

Pode-se também adicionar uma nova restrição em uma

tabela existente. Os exemplos abaixo alteram as
definições das tabelas pessoa e aluno.

ALTER TABLE pessoa ADD CHECK (nome <> ‘ ’);

ALTER TABLE aluno ADD FOREIGN KEY (idpessoa)

REFERENCES pessoa;
Removendo Uma Restrição
É possível remove uma restrição existente.
O nome da restrição deve ser informado no
comando. Se ela tiver sido gerada pelo sistema
pode ser consultada através do comando \d
nome_da_tabela.

ALTER TABLE pessoa DROP CONSTRAINT restricao;

ALTER TABLE pessoa

ALTER COLUMN pessoa DROP NOT NULL;
Alterando o Valor Default
Alterando o valor Default de uma coluna:
ALTER TABLE pessoa ALTER COLUMN estado SET
DEFAULT ‘RN’;

Removendo o valor Default de uma coluna:

ALTER TABLE pessoa ALTER COLUMN estado DROP
DEFAULT;
Renomeando Coluna e Tabela

Para renomear uma coluna:

ALTER TABLE pessoa
RENAME COLUMN telefne TO telefone;

Para renomear uma tabela:

ALTER TABLE pssoa RENAME TO pessoa;
PostgreSQL

Manipulação de Dados
 Inserindo Dados

Para inserir dados em uma tabela, utiliza-se o comando

INSERT , da seguinte forma:
INSERT INTO pessoa
VALUES ('JOSE MARIA DA SILVA', '12345678901', 'RUA DAS
FLORES 22','NATAL', 'RN',
TO_DATE('23/03/1961','DD/MM/YYYY'));

Aconselha-se listar as colunas explicitamente para facilitar

a compreensão:
INSERT INTO pessoa (nome, cpf, endereco, cidade, estado, nascimento)
VALUES ('MARIA DAS DORES', '01234567890', 'RUA SOL 85',
'NATAL', 'RN', TO_DATE('15/11/1956','DD/MM/YYYY'));
 Inserindo Dados

Também pode-se listar as colunas em diferente ordem:

INSERT INTO pessoa (cpf, nome, nascimento, endereco,

cidade, estado)
VALUES ('9876543210', 'RITA DE CASSIA',
TO_DATE('15/11/1956','DD/MM/YYYY'),
'RUA SOL 85', 'NATAL', 'RN');
Inserindo Dados

Pode-se copiar os dados de uma tabela diretamente

para outra:

INSERT INTO marias (nome,nascimento)

SELECT nome, nascimento
FROM pessoa
WHERE nome like ‘%MARIA%’;
Inserindo dados na Tabela
Pode-se utilizar o comando COPY para copiar
uma grande quantidade de dados em arquivos
texto previamente formatados. Isto
normalmente é bem rápido porque o comando
COPY é bem mais otimizado do que o comando
tradicional INSERT.

COPY pessoa FROM ´home/user/pessoa.txt´;

Removendo Linhas

A instrução DELETE é utilizada para remover

uma ou mais linhas de uma tabela.
A forma básica da instrução é:
DELETE FROM tabela;
A instrução acima removerá todas as linhas da
tabela, portanto, deve ser usado com muita
cautela.
Removendo Linhas

A clausula WHERE pode ser usada para

restringir as linhas que serão eliminadas. Como
por exemplo:

DELETE FROM automovel

WHERE modelo = 'GOL';
Modificando Dados

O comando UPDATE permite a modificação de

dados existentes no Banco de Dados.
Pode-se atualizar uma ou mais colunas de uma
ou mais linhas de uma tabela.
A estrutura do comando é composta de três
partes:
1. O nome da tabela e coluna(s) a serem
atualizadas;
2. O novo valor da(s) coluna(s) atualizadas;
3. Qual(is) linha(s) atualizar.
Modificando Dados

Forma básica:
UPDATE tabela SET coluna = novo_valor;

A instrução acima atualizará o valor da coluna em

todas as linhas da tabela, portanto deve ser
usado com cautela.
Modificando Dados

Também pode-se usar a clausula WHERE para

restringir as linhas que serão atualizadas.

UPDATE automovel
SET valor = 10000
WHERE modelo = 'UNO' AND ano = 2001;
Modificando Dados

Pode-se atualizar mais de uma coluna ao mesmo

tempo:

UPDATE automovel
SET valor = valor*1.1, proprietario = 'JORGE FILHO'
WHERE modelo = 'UNO' AND ano = 2001;
 Modificando Dados

Também pode-se usar subconsultas no comando

update.

UPDATE automovel
SET valor = valor*1.1
WHERE proprietario IN (SELECT nome
FROM pessoa
WHERE cidade = ‘NATAL’);
PostgreSQL

SELECT
Consultando uma Tabela

A instrução SELECT é utilizada para recuperar

informações de uma ou mais tabelas.
A estrutura básica do SELECT é composta de
três partes principais:
1. Lista das colunas a serem retornadas;
2.Lista das tabelas a serem consultadas;
3.Restrições (opcional).
O Comando SELECT

A instrução SELECT tem a seguinte estrutura

básica:
SELECT select_list FROM tabela(s);
Também pode compor a instrução as seguintes
cláusulas opcionais:
WHERE
GROUP BY
HAVING
ORDER BY
 Consultando uma Tabela

SELECT * FROM pessoa;

* indica que todas as colunas da tabela serão apresentadas.

nome | cpf | endereco | cidade | estado | nascimento

---------------------+-------------+-------------------+--------+--------+------------
JOSE MARIA DA SILVA | 12345678901 | RUA DAS FLORES 22 | NATAL | RN | 1961-03-23
MARIA DAS DORES | 01234567890 | RUA SOL 85 | NATAL | RN | 1956-11-15
RITA DE CASSIA | 9876543210 | RUA SOL 85 | NATAL | RN | 1956-11-15
(3 rows)
Consultando uma Tabela

Pode-se especificar na consulta apenas os campos

desejados:
SELECT nome, cidade, estado
FROM pessoa;

nome | cidade | estado

---------------------+--------+--------
JOSE MARIA DA SILVA | NATAL | RN
MARIA DAS DORES | NATAL | RN
RITA DE CASSIA | NATAL | RN
(3 rows)
A Cláusula SELECT

A cláusula SELECT pode:

Listar todas as colunas de uma tabela:
SELECT * FROM pessoa;
Listar colunas especificas de uma tabela:
SELECT nome, cidade FROM pessoa;
Executar operações entre colunas listadas:
SELECT matricula, (nota1 + nota2 + nota3)/3 FROM notas;
SELECT nome || sobrenome FROM pessoa;
A Cláusula SELECT

Executar operações aritméticas como uma

calculadora:
SELECT 3*4;
Chamar funções nativas ou programadas pelo
usuário:
SELECT random();
Aplicar funções sobre as colunas listadas:
SELECT substr(nome,1,4) FROM pessoa;
SELECT length(nome) FROM pessoa;
A Cláusula SELECT

O nome, de uma coluna, mostrado na saída

pode ser alterado através do uso de aliases:
SELECT matricula, (nota1 + nota2 + nota3)/3 AS media
FROM notas;

matricula | media
-----------+------------------
200123810 | 6.79999987284342
200278231 | 3.70000012715658
200144609 | 6.73333358764648
(3 rows)
 A Cláusula SELECT

Pode-se eliminar resultados duplicados, na

saída, usando a palavra reservada DISTINCT:
SELECT DISTINCT modelo FROM automovel;
treino=# SELECT modelo
FROM automovel; treino=# SELECT DISTINCT modelo
modelo modelo
-------- FROM automovel;
UNO modelo
PALIO --------
CORSA CORSA
GOL GOL
UNO PALIO
PALIO UNO
CORSA (4 rows)
GOL
(8 rows)
A Cláusula FROM

A cláusula FROM indica a origem dos dados de uma

consulta, que pode ser:
Uma tabela:
SELECT * FROM pessoa;
Duas ou mais tabelas (Joined Tables);
Subqueries;
Views.
A Cláusula WHERE

Após ser processada pela cláusula FROM, cada

linha da tabela virtual derivada é checada na
condição de busca.
Se o resultado da condição for verdadeiro, a
linha é colocada na tabela de saída.
Caso contrário, a linha é descartada do
resultado.
A Cláusula WHERE

A clausula WHERE restringe as linhas retornadas

em uma consulta.
SELECT modelo, ano, cor, valor
FROM automovel
WHERE modelo = 'GOL';

modelo | ano | cor | valor

--------+------+--------+-------
GOL | 1998 | AZUL | 9000
GOL | 2002 | BRANCO | 14000
(2 rows)
A Cláusula WHERE

Os operadores AND, OR e NOT são permitidos

na qualificação de uma Consulta.
SELECT modelo, ano, cor, valor
FROM automovel
WHERE modelo = 'GOL' AND ano < 2000;

modelo | ano | cor | valor

--------+------+------+-------
GOL | 1998 | AZUL | 9000
(1 row)
A Cláusula WHERE

SELECT modelo, ano, cor, valor

FROM automovel
WHERE modelo = 'GOL' OR modelo = 'PALIO';

modelo | ano | cor | valor

--------+------+--------+-------
-
GOL | 1998 | AZUL | 9000
PALIO | 2000 | BRANCO | 10500
GOL | 2002 | BRANCO | 14000
(3 rows)
A Cláusula WHERE

Outros Exemplos de WHERE:

A Cláusula GROUP BY

A cláusula GROUP BY é usada para agrupar todas

as linhas que compartilham os mesmos valores em
todas as colunas listadas.
A ordem das colunas não é importante.
O objetivo é reduzir cada grupo de linhas que
compartilham os mesmos valores em comum num
único grupo que representa todas as linha no
grupo.
 A Cláusula GROUP BY
EXEMPLO:
SELECT modelo SELECT modelo
FROM automovel; FROM automovel
GROUP BY modelo;
modelo
-------- modelo
UNO --------
PALIO CORSA
CORSA GOL
GOL PALIO
UNO UNO
PALIO (4 rows)
CORSA
GOL
(8 rows)
A Cláusula GROUP BY

EXEMPLO 2:
SELECT modelo, SUM(valor)
FROM automovel
GROUP BY modelo;

modelo | sum
--------+-------
UNO | 22000
CORSA | 12000
GOL | 23000
PALIO | 21000
(4 rows)
A Cláusula HAVING

Em muitas consultas nem todos os grupos

retornados pela cláusula GROUP BY são
importantes para o usuário.
A cláusula HAVING serve para eliminar grupos
de uma tabela agrupada.
Expressões na cláusula HAVING podem se
referir a expressões agrupadas ou não
agrupadas.
A Cláusula HAVING
EXEMPLOS:
Subqueries

SUBQUERIES:
Uma consulta dentro de outra consulta.
O resultado da subquery retorna uma tabela
virtual derivada que será usada pela consulta
principal.
Deve ser escrita entre parênteses.
Deve ser identificada por um alias.
 Subqueries

SUBQUERIES - Exemplo:
Retorne todos os modelos de carro que
possuem mais de duas unidades no estoque.
SELECT a.modelo, quantidade
FROM automovel a INNER JOIN (SELECT modelo AS m,
count(*) AS quantidade
FROM automovel
GROUP BY modelo) AS contagem
ON a.modelo = m
WHERE quantidade > 2;
Joined Tables

Joined Tables
Uma joined table é uma tabela derivada de
duas outras (real ou derivada) tabelas.
Os tipos de junção disponíveis no PostgreSQL
são:
Inner Join;
Outer Join;
Cross Join.
 Tabelas Exemplo

As tabelas abaixo serão usadas nos próximos

exemplos.
T1 T2
Joined Tables : CROSS JOIN

T1 CROSS JOIN T2;

Para cada combinação de linhas de T1 e T2, a
tabela derivada irá conter uma linha consistindo
de todas as colunas de T1 seguidas por todas as
colunas de T2.
Se as tabelas possuem N e M linhas
respectivamente, a tabela resultante terá N*M
linhas.
O CROSS JOIN é normalmente executado por
default, com a seguinte consulta simples:
SELECT * FROM T1,T2;
Joined Tables
Joined Tables
INNER JOIN:
Para cada linha R1 de T1, a tabela resultante
tem uma linha para cada linha em T2 que
satisfaz a condição de junção com R1.
Joined Tables
LEFT OUTER JOIN:
Primeiro, um inner join é executado. Então,
para cada linha em T1 que não satisfaz a
condição com nenhuma linha em T2, a linha é
adicionada com valores nulos nas colunas de
T2.
Joined Tables
RIGHT OUTER JOIN:
Primeiro, um inner join é executado. Então,
para cada linha em T2 que não satisfaz a
condição com nenhuma linha em T1, a linha é
adicionada com valores nulos nas colunas de
T1.
Joined Tables
FULL OUTER JOIN:
É a união do RIGHT OUTER JOIN e LEFT
OUTER JOIN.
Operações em Conjuntos
 Tabelas Exemplo
Tabela Clima Tabela Cidades

cidade | data | precp cidade | ano | temp_media

--------+------------+-------- --------+------------+--------
Natal | 18-03-2004 | 3.2 Natal | 2004 | 30
Caico | 18-03-2004 | 4.7 Macau | 2003 | 33
Touros | 19-03-2004 | 18.5 Caico | 2004 | 32
Patu | 20-03-2004 | 7.9 Touros | 2004 | 29
Apodi | 2003 | 31
Buzios | 2004 | 25
Operações em Conjunto
Assim como na álgebra relacional, as relações
participantes das operações de união, interseção e
diferença em SQL precisam ser compatíveis entre si, ou
seja, elas precisam ter o mesmo conjunto de atributos.
Vamos dar exemplos dessas operações, usando dois
conjuntos básicos: (a) o conjunto de todos os nomes
das cidades que possuem valores de precipitação, e
(b) o conjunto de todos os nomes das cidades que
possuem valores de temperatura.
Onde o conjunto (a) pode E o conjunto (b) pode
ser obtido com: ser obtido com:

SELECT cidade SELECT cidade

FROM clima; FROM cidades;
Operação União
Para se obter todos os nomes de cidades que
possuem valores de precipitação ou de
temperatura, ou ambos, escreve-se:
Resultado obtido:
(SELECT cidade
cidade
FROM clima) --------
UNION Natal
Caico
(SELECT cidade Touros
FROM cidades); Patu
Macau
Apodi
Buzios
Combinando Consultas

Consulta1 UNION Consulta2:

Retorna a união do resultado da consulta1 com
o resultado da consulta2, onde as linha
duplicadas são eliminadas.
Consulta1 UNION ALL Consulta2:
Semelhante ao UNION sendo que as linhas
duplicadas não são eliminadas
 Operação Interseção
Para encontrar todas as cidades que contenham
tanto valores de precipitação como valores de
temperatura, escreve-se:
Resultado obtido:
(SELECT cidade
cidade
FROM clima) --------
Natal
INTERSECT Caico
Touros
(SELECT cidade
FROM cidades);
Combinando Consultas

Consulta1 INTERSECT Consulta2:

Retorna a interseção do resultado da
consulta1 com o resultado da consulta2, onde
as linha duplicadas são eliminadas.
Consulta1 INTERSECT ALL Consulta2:
Semelhante ao INTERSECT sendo que as
linhas duplicadas não são eliminadas.
 Operador EXCEPT
Para encontrar todas as cidades que contenham
valores de precipitação e não contenham valores
de temperatura, escreve-se:
Resultado obtido:
(SELECT cidade
cidade
FROM clima)
--------
EXCEPT Patu

(SELECT cidade
FROM cidades);
Combinando Consultas

Consulta1 EXCEPT Consulta2:

Retorna todas as linhas que estão no resultado
da consulta1 mas não estão no resultado da
consulta2, as linha duplicadas são eliminadas.
Consulta1 EXCEPT ALL Consulta2:
Semelhante ao EXCEPT sendo que as linhas
duplicadas não são eliminadas.
PostgreSQL

Funções e Operadores
Operadores Lógicos
Os operadores lógicos disponíveis no PostgreSQL são:
AND, OR e NOT.
Operadores de Comparação
Operadores de Comparação

BETWEEN:
a BETWEEN x AND y
Equivalente a: a >= x AND a <= y

NOT BETWEEN
a NOT BETWEEN x AND y
Equivalente a: a < x OR a > y
Operadores de Comparação
IS NULL: Retorna TRUE se o valor da coluna for
nulo.
SELECT nome
FROM pessoa
WHERE cpf IS NULL;
IS NOT NULL: Retorna TRUE se o valor da
coluna não for nulo.
SELECT COUNT(*)
FROM pessoa
WHERE cpf IS NOT NULL;
Operadores e Funções
Matemáticas
Operadores e Funções
Matemáticas
Operadores e Funções
Matemáticas
Operadores e Funções de String
Funções Para Formatação de Datas
Padrões de Template Para Formatação
de Data e Hora
Funções de Agregação
PostgreSQL

Índices
Índices
Usados para melhorar a performance de
consultas ao banco de dados.
Úteis em consultas que retornam linhas
especificas e utilizam na cláusula WHERE a
coluna ou colunas nas quais o índice foi
construído.
Ao se criar um índice, o servidor constrói uma
árvore de busca para a(s) coluna(s) indexada(s).
Inúteis no caso de FULL TABLE SCANS ou
colunas não indexadas na cláusula WHERE.
Índices
EXEMPLO:
SELECT nome FROM pessoa WHERE idpessoa = 3145;

Se a coluna idpessoa não for indexada o servidor fará

uma busca em toda a tabela, linha por linha, retornando
a(s) linha(s) com idpessoa 3145.
Caso a coluna seja indexada, o servidor fará a busca
diretamente na árvore, tornando a consulta bem mais
eficiente.
Índices

Exemplo de criação de índice:

CREATE INDEX idpessoa_index ON pessoa(idpessoa);

Para remover o índice:

DROP INDEX idpessoa_index;
Índices
Por que não criar índices em todas as colunas?
1. Espaço: A criação de um índice implica na
criação de uma árvore de busca, aumentando
assim a necessidade de espaço físico para
armazenar o banco de dados;
2. Overhead nas operações de INSERT,
UPDATE e DELETE: Toda vez que um valor na
coluna indexada é atualizada ou uma linha é
inserida ou apagada a árvore precisa ser
“rebalanceada”, causando um considerável
overhead no desempenho do sistema.
Índices Multicoluna
Até 32 colunas podem ser especificadas no índice.
CREATE INDEX tb_xy_idx ON tb(x,y);
Útil em consultas que utilizam o operador AND nas
colunas do índice:
SELECT x, y FROM tb WHERE x = 3 AND y = 8;
Inútil no caso do operador OR:
SELECT x, y FROM tb WHERE x = 3 OR y = 8;
Também é usado no caso:
SELECT x, y FROM tb WHERE x = 3;
Inútil no caso:
SELECT x, y FROM tb WHERE y = 8;
Unique Indexes
Não permite valores duplicados em uma coluna:
CREATE UNIQUE INDEX idpessoa_index ON pessoa(idpessoa);

No caso de um índice multicoluna, serão rejeitados os

casos onde todas as colunas indexadas são iguais em
mais de uma linha.
Toda vez que uma “Unique Constraint” ou uma chave
primária é criada, um unique index é criado
automaticamente.
Índice de Expressão
Um índice também pode ser baseado em uma função ou
expressão escalar.

CREATE INDEX test1_lower_col1_idx ON test1

(lower(col1));

Útil para consultas como:

SELECT * FROM test1 WHERE lower(col1) = 'value';

Seqüências
Objeto usado para gerar números inteiros
exclusivos.
Pode ser compartilhada por vários usuários.
Normalmente usadas para gerar
automaticamente valores de chave primária.
Os números são gerados por uma rotina interna
do PostgreSQL.
Uma mesma seqüência pode ser usado por várias
tabelas.
Seqüências
Uma seqüência é criada através do comando
CREATE SEQUENCE:
 Seqüências

Parâmetros:
1. Temporary: O objeto seqüência é criado
somente para a sessão e apagado no fim da
sessão.
2. Increment by i: Especifica o intervalo entre
números de seqüência onde i é um número
inteiro, o valor default é 1, caso o valor de i
seja negativo a seqüência será
decrementada.
 Seqüências

Parâmetros:
3. Minvalue: Especifica o menor valor possível
na seqüência.
4. No Minvalue: Usa o valor default (1 ou-2^63
-1).
5. Maxvalue: Especifica o valor máximo que a
seqüência pode gerar.
6. No Maxvalue: Usa o valor default (2^63 -1
ou -1).
 Seqüências

Parâmetros:
7. Start With: Especifica o primeiro número a
ser gerado pela seqüência.
8. Cache: Especifica quantos valores serão
gerados previamente e alocados na memória.
9. Cycle: Especifica o valor máximo que a
seqüência pode gerar (Default 1).
 Seqüências

Parâmetros:
10. Cycle: Permite a seqüência continuar a gerar
valores depois de atingir o maxvalue
(ascendente) ou minvalue (descendente).
Caso o limite seja atingido, o próximo
número a ser gerado será o minvalue ou
maxvalue. Deve ser usado com cuidado para
gerar valores de chave primária. O valor
default é No Cycle.
Seqüências
Funções de Manipulação:
nextval: Avança e seqüência e retorna um novo
número.
nextval(‘sequencia’)
currval: Retorna o valor atual da seqüência.
currval(‘sequencia’)
setval: Seta um novo valor atual para a
seqüência.
setval(‘sequencia’,valor)
Seqüências
Para listar todas as seqüências do banco:
\ds

Para ver todos os parâmetros da sequencia:

SELECT * FROM nome_da_sequencia;
Seqüências
Exemplo:

INSERT INTO pessoa (idpessoa, nome)

VALUES (nextval(‘seq_pessoa’, ‘ROSANGELA MARIA’);

INSERT INTO aluno (idpessoa, matricula)

VALUES (currval(‘seq_pessoa’, 200425484);

SELECT currval(‘seq_pessoa’);
Seqüência
Para remover uma sequencia:
DROP SEQUENCE sequence_name;
Para alterar uma seqüência: ALTER SEQUENCE.
 PostgreSQL

Funções e Triggers
Funções

Também conhecidas como Stored Procedures, são

funções escritas em linguagem procedural, que são
armazenadas e executadas dentro do próprio banco.
Se muitas aplicações utilizam uma mesma função, é
vantagem armazená-la dentro do servidor de banco,
evitando assim cópias redundantes da mesma nas
diferentes aplicações.
Funções

A transferência dos códigos SQL, como SELECT, INSERT,

UPDATE e DELETE, ou de funções que necessitam de acessos
a banco, para dentro do servidor pode resultar em um grande
ganho de performance. Dentre as vantagens podemos citar:
1. Normalmente o DBA possui um melhor conhecimento
da linguagem SQL que os programadores.
2. Evita redundância de código, evitando que a mesma
instrução seja escrita várias vezes em diferentes
pontos da aplicação.
Funções

3.Ao invés de se passar o código SQL inteiro para o

servidor, a aplicação passa apenas os parâmetros da
consulta e espera o resultado, diminuído assim a
comunicação interprocessos e o tráfego de rede.
Em um sistema com centenas ou milhares de usuários
por exemplo, esse ganho pode ser imenso.
Funções

4. Toda vez que o servidor “recebe” uma instrução

SQL diferente da aplicação, ele necessita fazer o
parse e gerar o plano de execução antes de
executar a busca na base, que são etapas que
consomem um tempo considerável.
No caso de uma stored procedure, o parser e o plano
de execução são gerados somente na primeira vez
que a função é chamada, ficando armazenados para
as chamadas subseqüentes, gerando assim uma
considerável economia de tempo.
Funções

A atual versão do PostgreSQL (7.4.1) suporta as seguintes

linguagens procedurais: PL/pgSQL, PL/Tcl, PL/Perl, PL/TclU,
PL/PerlU, e PL/PythonU.
A linguagem PL/psSQL possui um padrão bastante semelhante
ao PL/SQL do Oracle e do SQL/Server, sendo portanto a mais
comum de ser utilizada.
Funções PL/pgSQL

As linguagens procedurais não vem instaladas por Default nos

bancos de dados.
Para instalar a linguagem PL/pgSQL o usuário deve executar o
seguinte comando:
$ createlang plpgsql meu_banco
Caso se deseje que todas os bancos que venham a ser criados
suportem o PL/pgSQL:
$ createlang plpgsql template1
Funções PL/pgSQL

Sintaxe básica para a criação de funções PL/pgSQL.

CREATE [OR REPLACE] FUNCTION nome(parametro1, parametro2…)

RETURNS tipo_de_dado_retornado AS '
DECLARE
variaveis;
BEGIN
corpo da procedure
END;
' LANGUAGE plpgsql;
Funções PL/pgSQL

Para se escrever uma função o usuário pode usar qualquer

editor de texto, ou alguma ferramenta gráfica como o PgAdmin
ou o PgAccess.

CREATE OR REPLACE FUNCTION helloworld()

RETURNS text AS '
DECLARE
a text;
BEGIN
a := ''Hello World'';
RETURN a;
END;
' LANGUAGE plpgsql;
 Funções PL/pgSQL

treino=# \i ‘helloworld.sql’
CREATE FUNCTION
treino=# select helloworld();
helloworld
-------------
Hello World
(1 row)
Funções PL/pgSQL - Estrutura

Declaração:
Todas as variáveis que serão usadas no bloco, devem ser
declaradas no sessão DECLARATION.
A única exceção são as variáveis definidas implicitamente num
loop FOR.
As variáveis podem assumir os mesmos tipos suportados na
linguagem SQL do PostgreSQL, como; integer, varchar,
numeric, float e date.
Funções PL/pgSQL - Estrutura

Declaração:
Quando se quer utilizar o mesmo tipo de uma coluna de uma
tabela, aconselha-se usar o %TYPE. Pois garante a consistência
caso o tipo da coluna venha a mudar.
Ao invés de
v_nome varchar(30);
É melhor usar
v_nome pessoa.nome%TYPE;
Funções PL/pgSQL - Estrutura

Declaração:
Uma variável composta pode ser declarada com todas as
colunas de uma tabela %ROWTYPE (semelhante a um registro).

DECLARE
r_pessoa pessoa%ROWTYPE;
BEGIN
r_pessoa.nome := 'CREMILDA';
Funções PL/pgSQL - Estrutura

Declaração:
Os parâmetros de entrada da função são acessados no corpo
como $1 (parametro1), $2 (parametro2). Pode-se usar
ALIASES para se tornar mais amigável.
CREATE FUNCTION teste(real) RETURNS real AS ‘
DECLARE
v_valor ALIAS FOR $1;
BEGIN
RETURN 10*v_valor;
END; ‘ LANGUAGE plpgsql;
Funções PL/pgSQL - Estrutura

Instruções básicas: Atribuição

Um valor pode ser atribuído a uma variável ou um registro.
Exemplos:
v_idade := 23;
v_taxa := v_preco * 0.1
Funções PL/pgSQL - Estrutura

Instruções básicas: SELECT INTO

Permite que o resultado de uma consulta select seja atribuído
a uma variável, lista de variáveis ou um registro.
A consulta só pode retornar uma única linha.
SELECT nome, cpf
INTO v_nome, v_cpf
FROM pessoa
WHERE idpessoa = 12548;
Funções PL/pgSQL - Estrutura

Estruturas de Controle: RETURN

Sintaxe:
RETURN <expressao>;
Retorna o valor da expressão e finaliza a função.
Funções PL/pgSQL - Estrutura

Estruturas de Controle: Condicionais IF

A instrução IF permite a execução de comandos se uma
determinada condição for satisfeita.
O postgreSQL tem 4 formas de IF.
IF ... THEN
IF ... THEN ... ELSE
IF ... THEN ... ELSE IF
IF ... THEN ... ELSIF ... THEN ... ELSE
Funções PL/pgSQL - Estrutura

Loops Simples: LOOP

Funções PL/pgSQL - Estrutura

Loops Simples: WHILE

Repete a execução das instruções enquanto a condição
for verdadeira.
Funções PL/pgSQL - Estrutura

Loops Simples: FOR

Repete a execução sobre uma escala de valores
inteiros.
 Funções PL/pgSQL - Estrutura

Loop sobre o resultado de uma consulta: FOR

Existe uma variação do FOR que permite interagir com os
resultados retornados de uma consulta.

FOR c_aluno IN SELECT matricula, ira

FROM aluno WHERE status = 'A' LOOP
IF c_aluno.ira >= 9 THEN
INSERT INTO elite (matricula, ira)
VALUES (c_aluno.matricula, c_aluno.ira);
END IF;
END LOOP;
 Funções PL/pgSQL - Estrutura

Erros e Mensagens
A instrução RAISE reporta mensagens e erros.
Exemplos:

RAISE EXCEPTION '‘Preço nao pode ser negativo %'', NEW.minprice;

RAISE NOTICE ''O valor de i neste ponto é %'', i;

Triggers

Triggers são utilizadas para definir regras de restrições

complexas, ou executar alguma ação ou função depois de algum
evento especifico.
Uma trigger pode ser disparada antes ou depois de uma
operação INSERT, UPDATE ou DELETE, tanto a cada linha
modificada como após uma instrução SQL inteira.
Triggers

Uma trigger é criada através do comando CREATE FUNCTION

como uma função sem argumentos e retorno do tipo trigger.
Exemplo de utilização de Triggers:
Chamar uma função que verifique se o número do
CPF é válido toda vez que uma linha é inserida na
tabela pessoa ou o valor do campo CPF é atualizado.
 Triggers

O exemplo a seguir ilustra a criação de uma trigger

procedure que não permite preços negativos na
tabela de preços.

CREATE OR REPLACE FUNCTION public.preco_min()

RETURNS trigger AS
'
BEGIN
IF NEW.minprice < 0 THEN
RAISE EXCEPTION ‘‘Preço nao pode ser negativo %’', NEW.minprice;
END IF;
RETURN NEW;
END;
'
LANGUAGE 'plpgsql' VOLATILE;
 Triggers

Na tabela, deve-se criar o gatilho que disparará a trigger

procedure nas atualizações e inserções na tabela price.

CREATE TRIGGER price_minimo

BEFORE INSERT OR UPDATE
ON public.price
FOR EACH ROW
EXECUTE PROCEDURE public.preco_min();
Usuários e Privilégios de Banco de
Dados
Usuários
Todo cluster de banco de dados possui um conjunto de
um ou mais usuários.
Os usuários do banco não possuem nenhuma
correspondência com os do S.O. onde o servidor roda.
Um nome de usuário é global para todo o cluster de
banco, e não para cada banco individual.
Usuários
Usuários podem possuir objetos (como tabelas),
conceder acesso a seus objetos à outros usuários, e
receber autorização de acesso a objetos de outros
usuários.
Durante a instalação, um usuário predefinido é criado e
através dele pode-se conectar ao cluster para criar
novos usuários ou executar tarefas administrativas.
Normalmente o nome do usuário inicial é postgres.
Usuários
Para criar um novo usuário:
CREATE USER nome;
Para remover um usuário:
DROP USER nome;
Também podem ser usados, a partir do S.O. os
programas createuser e dropuser:
createuser nome
dropuser nome
Atributos de Usuários
Um usuário pode possuir determinados atributos que
determinam seus privilégios e interage com o sistema de
autenticação com o cliente.
Superuser: Possui todos os privilégios do banco,
somente um superusuário pode criar novos usuários.
CREATE USER valeria CREATEUSER
Atributos de Usuários
Database creation: Concede ao usuário a permissão de
criar novos bancos de dados.
CREATE USER valeria CREATEDB
Password: Significativo somente se o método de
autenticação requerer um password. Os métodos
password, md5 e crypt requerem passwords.
CREATE USER valeria PASSWORD ‘senha’
Todos os atributos podem ser modificados através do
ALTER USER.
Grupos
Para simplificar a administração, pode-se criar grupos
de usuário.
Cada privilégio concedido ou revogado a um grupo, é
concedido ou revogado a todos os usuários do grupo.
CREATE GROUP turma01;
ALTER GROUP turma01 ADD USER xico, maria;
ALTER GROUP turma01 DROP USER xico, maria;
Privilégios
Quando um usuário cria um novo objeto no banco, ele se
torna o proprietário do objeto.
Por default, somente o proprietário e o superusuário
tem acesso total ao objeto.
O proprietário pode conceder privilégios sobre seus
objetos a outros usuários.
Exemplos de privilégios: SELECT, INSERT, UPDATE, DELETE,
RULE, REFERENCES, TRIGGER, CREATE, TEMPORARY, EXECUTE,
USAGE e ALL PRIVILEGES.
Privilégios
Concedendo um privilégio:
GRANT UPDATE ON pessoa TO maria;
GRANT SELECT ON pessoa TO GROUP turma01;
GRANT EXECUTE ON function_name TO PUBLIC;
GRANT ALL PRIVILEGES ON pessoa TO coordenador;

Revogando um privilégio:
REVOKE ALL ON pessoa FROM maria;
REVOKE INSERT ON pessoa FROM GROUP turma01;
Privilégios
WITH GRANT OPTION permite ao usuário que recebe o privilégio
concedê-lo a outros usuários:

GRANT REFERENCES
ON pessoa TO benedita WITH GRANT OPTION;
Transações em PostgreSQL
Transações
As transações são um conceito fundamental em sistemas
de bancos de dados. Uma transação envolve vários
passos em uma operação de tudo-ou-nada.
Os passos intermediários de uma transação não são
visíveis por outras transações, porque se alguma coisa
falhar, nenhum passo será efetivamente executado.
Transações
Considere um exemplo que se deseja fazer uma
transferência bancária da conta de Alice para a conta
de Bob.
UPDATE conta SET saldo=saldo-100.00
WHERE nome=´Alice´;
UPDATE conta SET saldo=saldo+100.00
WHERE nome=´Bob´;
Desta maneira, não existe nenhuma garantia que as duas operações
serão efetivamente executadas ou nenhuma delas. Isto só é obtido
agrupando-se as duas operações em uma transação.
Transações
Uma transação é atômica: ou ela acontece
completamente ou não acontece.
Quando uma operação é completada ela é efetivamente
percebida pelo sistema de bd e suas alterações são
verdadeiramente armazenadas no bd.
Transações concorrentes não enxergam resultados
parciais umas das outras.
Uma transação em PostgreSQL é denotada pelos
comandos BEGIN e COMMIT.
Transações
A transação bancária pode ser escrita como:
BEGIN;
UPDATE conta SET saldo=saldo-100.00
WHERE nome=´Alice´;
UPDATE conta SET saldo=saldo+100.00
WHERE nome=´Bob´;
COMMIT;
Pode-se desejar que a transação não seja efetivamente executada.
Neste caso, utiliza-se o comando ROLLBACK no lugar do COMMIT.
Manutenção de Rotina
Manutenção de Rotina
No PostgreSQL existem algumas rotinas de manutenção
que devem ser executadas rotineiramente, afim de
manter o servidor rodando eficientemente.
Essas tarefas podem ser agendadas para serem
executadas regulamente através de ferramentas do SO,
como o CRON, por exemplo.
Vacuuming
O comando VACUUM tem a função de:
1. Recuperar espaço em disco ocupador por linhas
apagadas ou atualizadas;
2. Atualizar as estatísticas usadas pelo PostgreSQL
query planner (gerador de planos de consultas do
PostgreSQL).
A freqüência do uso do comando VACUUM vai
depender da necessidade de cada base.
Reindexação

Em algumas situações é necessário reconstruir os

índices periodicamente através do comando REINDEX.
No PostgreSQL 7.4, a necessidade de reconstrução de
índices foi reduzida drasticamente em relação a versões
anteriores do PostgreSQL.
Backup e Restore
SQL Dump
Gera um arquivo texto com comandos SQL, que quando
executado no servidor de bancos, recria a base de
dados no mesmo estado do momento que o arquivo foi
gerado.
pg_dump nome_do_banco > arquivo
Por default o pg_dump se conecta ao banco usando o
mesmo nome de usuário do SO. Para usar outro usuário
use o parâmetro –U.
O usuário precisa ter acesso a todos os objetos, por
isso aconselha-se usar um superusuário para executar o
backup.
Recuperando
O arquivo texto gerado pelo pg_dump pode ser lido pelo
psql.
Recuperando o backup.
psql nome_do_banco < arquivo
O banco terá que ter sido previamente criado através
do comando createdb (createdb –T template0
nome_do_banco).
Pg_dumpall
O comando pg_dump faz o backup de um banco por vez,
para se fazer o backup de todo o database cluster,
deve-se usar o programa pg_dumpall.
pg_dumpall > arquivo
Recuperando o Backup:
psql template1 < arquivo
Compressão de Backups
Para poupar espaço em disco, pode-se gerar os backups
comprimidos.
pg_dump dbname | gzip > filename.gz
pg_dump dbname | split -b 1m - filename
Recuperando:
createdb dbname gunzip -c filename.gz | psql dbname
createdb dbname cat filename* | psql dbname
File System Level Backup
Outra forma de backup é simplesmente copiar todos os
arquivos de dados que o PostgreSQL usa para
armazenar os dados.
Só pode ser executado com o banco off-line, ou seja,
deve-se dar um shutdown no banco antes de começar o
backup.
tar -cf backup.tar /usr/local/pgsql/data
Bibliografia
PostgreSQL 7.4.1 Documentation by The PostgreSQL
Global Development Group Copyright © 1996-2003 The
PostgreSQL Global Development Group