Curso de PostgreSQL: Um pouco Além dos Comandos

Introdução ao PostgreSQL: um pouco
além dos comandos
MARCOS THOMAZ DA SILVA

Breve Histórico
Derivado do pacote POSTGRES escrito na
Universidade da Califórnia em Berkeley;
Implementação do POSTGRES começou em 1986;
Em 1994 foi adicionado um interpretador SQL ao
Postgres (Postgres95, antes usava PostQUEL);
Deu origem ao Informix da IBM;
Em 1996 recebeu o nome de PostgreSQL,
ganhando diversos outros recursos.

No Brasil
Caixa, BB e Serpro;
Comunidade PGBR;
Timbira e EnterpriseDB;

Recursos
Sub-Consultas;
Integridade Referencial;
Linguagem Procedural para Functions e Procedures
pl/pgsql, pl/python, pl/perl, pl/java, pl/pascal, pl/ruby, pl/C,
pl/R
Gatilhos (Triggers);
Tipos Definidos Por Usuário;
Esquemas (schemas);
Áreas de Armazenamento (Tablespaces);
Savepoints;
Dados geoespaciais;
Herança de tabelas;

Ambientes de Gerenciamento
Modo texto: psql;
Modo gráfico:
pgAdmin III;
EMS PostgreSQL Manager;
Acqua Studio;
Web: phpPgAdmin;

Criando o banco de dados
CREATE DATABASE <Nome_Do_Banco>
[ WITH
[ OWNER = <Usuario_Criador_Banco> ]
[TEMPLATE = <Template> ]
[ TABLESPACE = <table_space>
[ ENCODING = <Encoding> ]
[ LC_COLLATE = <collate> ]
[ LC_CTYPE = <collate> ] ];
Exemplo:
CREATE DATABASE testeerin
WITH OWNER=curso_erin
TEMPLATE = template0
TABLESPACE = pg_default
ENCODING = 'UTF8'
LC_COLLATE = 'Portuguese_Brazil.1252'
LC_CTYPE = 'Portuguese_Brazil.1252';

Criação de Usuários (Role’s)
Porque criar:
Segurança (mesma regra do root);
Separação de ambientes;
Controle de acesso e execução;
O DBA pode realmente gerenciar o banco.

Criação de Usuários (Role’s)
Comando:
CREATE ROLE <Seu_Usuario> LOGIN
PASSWORD <Sua_Senha>
[SUPERUSER] [INHERIT]
[CREATEDB/NOCREATEDB]
[CREATEROLE/NOCREATEROLE]
[REPLICATION/NOREPLICATION];
Exemplo:
CREATE ROLE cursopgerin LOGIN
PASSWORD ‘cursopgerin’
SUPERUSER INHERIT CREATEDB CREATEROLE
NOREPLICATION;

Exercício de Fixação 01
Criar um banco de dados com o template0,
encoding UTF8, collate (LC_CTYPE e
LC_COLLATE) Portuguese_Brazil.1252, cujo nome
seja erin_<seunome>. O usuário (role) criador do
banco deve ter o seu nome (apenas o primeiro
nome), deve ser superusuário, poder criar outros
usuários, criar bancos, mas não deve poder realizar
replicação. A senha fica a sua escolha.

Tipos de Dados
char / varchar (character / character varying);
text;
integer, smallint, bigint (2, 4 e 8 bytes
respectivamente);
decimal, numeric, real e money;
serial;
date, time, timestamp (with/without timezone);
boolean;
bytea, lo;
array;
line, point, polygon;
json, macaddr;

Tipo de dados – cada um na sua...
Como armazenar...
Datas de Nascimento?
Nomes de pessoas?
Textos variáveis (observações)?
Horários?
Valores monetários?
Número de CPF?
Números de Telefone?

Criação de Tabelas
O que são? Excel????
Comando básico...
CREATE TABLE <tabela> (
<campo01> <tipo> [<requerido>] [DEFAULT <def>],
<campo02> <tipo> [<requerido>] [DEFAULT <def>],
[CONSTRAINT <nome_constraint> <tipo_constraint> (
<campo_constraint> )]
);
Exemplo:
CREATE TABLE categorias(
id serial NOT NULL,
descricao character varying(80),
CONSTRAINT categorias_pk PRIMARY KEY (id) )
WITH (OIDS=TRUE);

No banco criado no exercício 01, crie uma tabela
chamada contatos com os seguintes campos:
CAMPO TIPO
NOME CHARACTER VARYING(80)
CIDADE CHARACTER VARYING(80)
TELEFONE CHARACTER VARYING(20)
VL_ULT_COMPRA NUMERIC(10,2)
VL_DEBITO MONEY

Inserindo informações nas tabelas
A instrução utilizada para inserir informações é INSERT
Permite adicionar (quase) qualquer tipo de dado dentro
de uma tabela;
Comando:
INSERT INTO <Tabela> [ (Campo1, Campo2[, Campo3] )
VALUES (<Valor1>,<Valor2>[,<Valor3>]) [ RETURNING
<campo> ];
Exemplo
INSERT INTO categorias (descricao) VALUES (‘Cerâmicas’);
Ou
INSERT INTO categorias (descricao) VALUES
(‘Cerâmicas’),(‘Roupas’),(‘Frios’),(‘Ferramentas’)

Usando como base o exercício anterior, insira os
seguintes registros na tabela criada:
NOME CIDADE VL_ULT_COMPRA VL_DEBITO
FULANO RIO BRANCO 100 100
CICLANO RBCO 80 80
BELTRANO RIO BRANCO-AC 120.50 20.50
NOCEGO RIO BRANCO-AC 30 60
NOCEGO RIO BRANCO-AC 120 120
Além destes registros, insira mais 5 registros nessa
tabela, com o VL_DEBITO igual a 0.

Removendo Registros das Tabelas
Comando DELETE é utilizado;
Comando:
DELETE FROM <Tabela> [ WHERE <Condicao>]
Exemplo
DELETE FROM categorias;
DELETE FROM contatos WHERE VL_DEBITO < 10;
DELETE FROM clientes WHERE nome like
‘FULANO*’

Usando como base a tabela utilizada no
EXERCÍCIO 03, Resolva a seguinte situação:
O dono da loja quer fazer uma limpeza em seu banco de
dados e quer remover todos os registros de contatos que
não possuam débitos.
Que comando deve ser executado???
delete from Contatos where vl_debito=‘0’
delete from Contatos where vl_debito=0::money

Constraints / Restrições
PRIMARY KEY – Chave primária;
UNIQUE KEY – Chave Única;
FOREIGN KEY – Chave Estrangeira;
CHECK – Validação;
QUAIS AS DIFERENÇAS ENTRE CHAVE PRIMÁRIA E CHAVE
ÚNICA?

Alterando Estrutura de Uma Tabela
Mudanças Gerais na Tabela:
Necessidade de Acréscimo de Campos;
Necessidade de Retirada de Campos;
Mudança de Tipos de Campos;
Acréscimo de Constraints (Primary Key, Foreign
Key, Unique Key, Check);

Alterando Estrutura de Uma tabela
Exemplos:
ALTER TABLE ct DROP COLUMN tipo;
ALTER TABLE ct ADD COLUMN testes
character(1);
ALTER TABLE ct ADD CONSTRAINT ct_chk2
CHECK (testes = 'S' or testes='N');
ALTER TABLE ct ALTER COLUMN valor TYPE
money;
ALTER TABLE ct RENAME vlr TO valor;

Estrutura de Tabela – Testando...
A estrutura apresentada no Exercício 02 atende aos
dados que persistem nela??
Selecione todos os registros que correspondam a Rio
Branco?
Existem usuários duplicados na tabela?
Os valores do campo cidade estão corretos? São
confiáveis?
Na tabela existem 2 contatos chamados NOCEGO,
como ficaria para excluir apenas um deles?
Execute os seguintes comandos na tabela e veja o que
ocorre:
insert into contatos (nome, VL_DEBITO) values (‘Teste
01’,’1.250,25’);

Modifique a tabela usada no exercício anterior,
realizando as seguintes operações:
Adicionando uma coluna para armazenar o estado (UF);
Adicionar um campo para armazenar a data de
nascimento;
Adicionar um campo do tipo SERIAL com o nome ID e
torná-lo chave primária;
Colocar o campo nome como Chave Única (realizando os
ajustes necessários);
Modifique o campo VL_ULT_COMPRA para o tipo
MONEY;

Alterando Registros de Uma Tabela
Comando:
UPDATE <Tabela> SET
<campo1>=<valor_campo_1> [WHERE <condicao>]
Exemplos:
UPDATE categorias SET observacao=NULL;
UPDATE contatos SET VL_DEBITO=0 WHERE
VL_DEBITO < 10;
UPDATE clientes SET nome=‘FULANO DE TAL’
WHERE nome like ‘FULANO*’;
UPDATE clientes SET
VL_DEBITO=VL_DEBITO*1.1 WHERE VL_DEBITO >
100 AND VL_ULT_COMPRA > 80;

Com base na tabela existente, altere os registros
existentes, informando as datas de nascimento dos
contatos;
Adicione um juros de 20% para todos os contatos com
VL_DEBITO maior ou igual a 100;
Adicione um juros de 10% para todos os contatos com
VL_DEBITO entre 60 e 100;
Adicione um juros de 5% para todos com valores
menores que 60;
Crie uma tabela chamada cidades com os campos id
(serial), nome (character varying(80) ) e uf (character(2)
), adicione as cidades usadas na tabela contatos. Em
seguida, insira na tabela contatos um campo chamado
cidade_id. Altere-o para o valor das cidades
correspondentes. Remova o campo cidade da tabela
contatos e então defina o campo cidade_id como chave
estrangeira apontando para a tabela cidades.

Buscando Registros – Parte 01
Comando:
SELECT <lista_de_valores> FROM <tabelas>
[WHERE <condicoes>]
ONDE:
<lista_de_valores> - Campos, Expressões ou *
<tabelas> - Uma ou mais tabelas (separadas por
vírgula) que terão seus valores representados na
listagem
<condicoes> - Restrições de filtragem dos registros.
Se omitido, exibe todos os registros.

Exemplos Simples
SELECT * FROM categorias;
SELECT ID, NOME FROM CIDADES
SELECT * FROM CIDADES WHERE UF = ‘AC’
SELECT nome, vl_debito,
(vl_debito*1.10) as vl_deb_com_juros
FROM contatos;
SELECT upper(a.nome) as contato,
b.nome||’-’||b.uf as cidade FROM
contatos a, cidades b WHERE
a.cidade_id=b.id AND b.uf = ‘AC’;

SELECT.... JOIN...
O que são os JOIN’s ???
Tipos:
INNER JOIN;
LEFT / RIGHT
FULL JOIN;

SELECT ... JOIN .... - EXEMPLOS
SELECT upper(contatos.nome) as contato,
cidades.nome||’-’||cidades.uf as cidade
FROM contatos INNER JOIN cidades ON
cidade_id=id WHERE b.uf = ‘AC’;
SELECT * FROM CLIENTES C LEFT OUTER
JOIN COMPRAS C2 ON C2.ID_CLIENTE = C.ID

SELECT...GROUP BY
Realiza agrupamento de valores;
Utiliza funções de agregação: SUM, MAX, MIN,
COUNT, AVERAGE (AVG);
As “dimesões” que aparecem na lista do select,
devem ser adicionadas ao GROUP BY
Agrupamento aceita funções condicionais (CASE);

SELECT ... GROUP BY - EXEMPLOS
SELECT COUNT(*) FROM contatos;
SELECT a.nome as cidade, COUNT(*) FROM cidades
a, contatos b WHERE A.id=b.cidade_id;
a INNER JOIN contatos b WHERE a.id =
b.cidade_id;
a LEFT JOIN contatos b WHERE a.id =
b.cidade_id;
a RIGHT JOIN contatos b WHERE a.id =
b.cidade_id;
SELECT a.nome, (select count(*) from contatos
b WHERE a.id=b.cidade_id) FROM cidades a

SELECT.... E MAIS ALGUNS EXEMPLOS
Listar a quantidade de pessoas de uma determinada
cidade, separando por sexo:
select a.nome, SUM( case b.sexo WHEN ‘M’ then 1
else 0 end) as M, SUM( case b.sexo WHEN ‘F’ then 1
else 0 end) as F FROM cidades a LEFT JOIN clientes
b ON b.cidade_id = a.cidade_id WHERE a.id=1
Listar os clientes e seu débito total, cujo débito total
é maior que R$ 1.000,00:
Select c.nome, sum(vl_debito) from clientes c
group by c.nome having sum(vl_debito) > 1000

Mais do mesmo???
Onde estão Schema’s, Triggers, Procedures,
Functions, Índices e TableSpaces???
Pra que serve cada um???

Cenário 01
A Universidade Federal do Acre possui um ERP que
dentre seus módulos podemos destacar: acadêmico,
financeiro, orçamentário, compras, frotas, RH,
licitação, almoxarifado, espaço físico e contratos. O
banco de dados possui cerca de 800 tabelas.
Como organizar essas tabelas para facilitar a
manutenção?
Como não se perder, nem inverter o nome de
tabelas com um ambiente tão complexo?
A tabela “estrutura” se refere a parte organizacional
ou física???
SCHEMAS

Schemas
Os schemas são estruturas lógicas, usadas para
separar o conteúdo de bancos de dados;
Podem estar contidos dentro de schemas tables,
views, procedures, etc;
Se a tabela está em um schema, esse deve estar no
path do usuário que acessa o banco de dados.
Comando:
Create schema Financeiro;
Create schema Academico;

Schema’s – select entre schema’s
Public – Visível automaticamente para todos ;
<User> - Visível apenas ao usuário (de forma
explícita);
Exemplo, se tivermos os schemas academico e rh,
criação de tabelas:
Create table academico.pessoas (...);
Create table rh.pessoas (...);
Exemplo de select:
select * from academico.pessoas p1,
rh.pessoas p2 where p1.id=p2.id

Schema’s
Perguntas:
E se eu quiser dar um select sem especificar o schema?
set search_path=“$user”, public, rh, academico;
Se eu estiver usando um schema, posso ter chaves
estrangeiras apontando para uma tabela de outro
schema?
Posso ter tabelas com o mesmo nome e estrutura?
E nesse caso, se eu tenho duas tabelas iguais, adicionei
ambos os schema’s no search_path, e digitar select *
from tabela, como saber de qual schema são os dados?

Preparando para as regras de negócio...
TABELA: categorias
CAMPO TIPO PK UK FK REF
ID SERIAL X
DESCRICAO VARCHAR(80)
TABELA: clientes
ID SERIAL X
NOME VARCHAR(80) X
DTN DATE
ATIVO BOOLEAN
SEXO CHAR(1)

TABELA: produtos
ID SERIAL X
NOME VARCHAR(80) X
VL_COMPRA MONEY
LUCRO NUMERIC(7,3)
VL_VENDA MONEY
EST_MINIMO INTEGER
CATEGORIA_ID INTEGER X CATEGORIAS

TABELA: pedidos
ID SERIAL X
CLIENTE_ID INTEGER X CLIENTES
VL_COMPRA MONEY
FPGTO CHAR(1)
DESCONTO MONEY
VL_TOTAL MONEY
FECHADO BOOLEAN

TABELA: pedidos_itens
ID SERIAL X
PEDIDO_ID INTEGER X PEDIDOS
PRODUTO_ID INTEGER X PRODUTOS
QTD INTEGER
VL_UN MONEY

REGRAS ----
Tabela categorias
Não pode ter categorias com descrições iguais;
Tabela clientes:
Não podem haver clientes com o mesmo nome, nascidos
no mesmo dia;
A data de nascimento não pode ser nem maior nem igual
a data atual;
Se um cliente estiver inativo, ele não pode sofrer
alterações;
Sexo obrigatoriamente deve ser: M, m, F ou f

REGRAS ----
Tabela produtos:
Não podem haver produtos com o nome repetido;
Valor da compra deve ser menor ou igual ao valor da
venda;
Lucro deve ser maior ou igual a zero;
Estoque mínimo deve ser maior ou igual a zero;
Deve ser uma categoria válida;
Se o valor de venda não for informado, deve ser pego o
valor de compra e calculado o juros.

REGRAS -----
Tabela pedidos:
Fpagto só pode ser V (a vista) ou P (a prazo);
Se o pedido estiver fechado é porque foi quitado pelo
cliente e não pode sofrer alterações;
Valor total deve ser calculado pegando o valor da
compra, menos o desconto.
O desconto deve ser maior ou igual a zero;
O valor da compra deve ser pego automaticamente,
conforme são adicionados os itens.
Tabela pedidos_itens:
Quantidade deve ser maior que zero;
Valor Unit. Deve ser pego automaticamente da tabela de
produtos.

E AGORA??!
Regras de negócio no banco? Simples... Triggers e
procedures!

TRIGGER
São automatizações do banco de dados;
São disparados a partir de eventos como insert,
update e delete;
Permitem a execução de diversas outras operações;

PROCEDURES / FUNCTIONS
São funções executadas dentro do banco de dados;
Pode ser desenvolvidas em diversas linguagens
Por padrão, utilizasse PL/pgsql;
Linguagem simples com selects dentro dos
comandos;
Permite retornos simples ou listas;
No postgreSQL todos as triggers executam uma
função especial (trigger functions).

Modelo de Triggers no PostgreSQL
Tabela
Comando
INSERT
Dispara a
Trigger OnInsert
Executa a Trigger
Function

Functions / Procedures
Comando:
CREATE OR REPLACE FUNCTION <SuaFuncao>(
<parametros> ) RETURNS <retorno> AS
$BODY$
<declaração_de_variáveis>;
BEGIN
<codigo>
END;
$BODY$ LANGUAGE plpgsql;

Trigger Functions
Comando:
CREATE OR REPLACE FUNCTION
<SuaFuncao>() RETURNS trigger AS
$BODY$
<declaração_de_variáveis>;
BEGIN
<codigo>
RETURN <new_ou_old>;
END;
$BODY$ LANGUAGE plpgsql;

Trigger
CREATE TRIGGER <nome_trigger>
{AFTER|BEFORE} {INSERT|UPDATE|DELETE}
ON <suaTabela> FOR EACH
{ROW|STATEMENT}
EXECUTE PROCEDURE
<nome_da_trigger_function>();

Exemplo
Create table fornecedores(
id serial not null,
nome varchar(80),
saldo money,
CONSTRAINT pk_forne PRIMARY KEY (id)
);
Create table venda(
id serial not null,
fornecedor_id integer,
data date,
valor money,
CONSTRAINT pk_venda PRIMARY KEY (id),
CONSTRAINT fk_venda FOREIGN KEY (fornecedor_id)
REFERENCES fornecedores (id) ON UPDATE NO ACTION ON
DELETE CASCADE
);

Exemplo Continuação
Create or replace function ajusta_saldo()
returns trigger AS
$BODY$
BEGIN
update fornecedor
set saldo = coalesce(saldo,0)+NEW.valor
where id = NEW.fornecedor_id;
RETURN NEW;
END
$BODY$
AS LANGUAGE plpgsql;

Exemplo – Continuação
CREATE TRIGGER tr_ajusta_saldo AFTER
INSERT ON venda FOR EACH ROW EXECUTE
PROCEDURE ajusta_saldo();

PENSANDO EM DESEMPENHO...
Criação de tablespaces
O que são?
Como criá-las?
Quais as vantagens?
Como usá-las?
Índices:
Explain;
Tipos de índice;
Views:
Melhorando modelos
Rules;
Desempenho ainda incomoda: Particionamento de
tabelas;

Curso de PostgreSQL: Um pouco Além dos Comandos

Mais conteúdo relacionado

Mais procurados

Destaque

Semelhante a Curso de PostgreSQL: Um pouco Além dos Comandos

Mais de Marcos Thomaz

Curso de PostgreSQL: Um pouco Além dos Comandos