Procedimentos armazenados são uma forma de armazenar a lógica do banco de dados no lado do servidor e podem ser executados por vários clientes. Eles são uma ferramenta muito útil para administradores e programadores de banco de dados, pois permitem encapsular a lógica complexa em uma única unidade chamável, reduzindo o código duplicado, aumentando a segurança e melhorando o desempenho.

Um procedimento armazenado no PostgreSQL é um bloco nomeado de instruções PL/pgSQL que podem ser executadas com um único comando. A sintaxe para criar um procedimento armazenado no PostgreSQL é a seguinte:

CREATE [OR REPLACE PROCEDURE] nome_procedimento(arg1 tipo_dado1, arg2 tipo_dado2, ...)
RETURNS tipo_dado_retorno
LANGUAGE plpgsql
AS $$
DECLARE
-- declaração de variáveis locais, se houver
BEGIN
-- declarações PL/pgSQL
END;
$$;

Onde:

• nome_procedimento é o nome do procedimento armazenado
• arg1, arg2, etc. são os parâmetros do procedimento armazenado
• tipo_dado1, tipo_dado2, etc. são os tipos de dados dos parâmetros
• tipo_dado_retorno é o tipo de dados do valor de retorno

e a seção DECLARE é usada para declarar variáveis locais, se necessário. A lógica real do procedimento armazenado é escrita dentro de blocos BEGIN e END, usando instruções da linguagem PL/pgSQL.

A cláusula LANGUAGE especifica o idioma do procedimento armazenado, que é plpgsql neste caso.

O símbolo $$

O símbolo $$ usado na última linha de um procedimento PL/pgSQL é usado para definir o início e o fim do corpo do procedimento. É uma sintaxe especial usada para definir uma string literal que abrange várias linhas. Na prática, é possível usar qualquer string com essa finalidade, desde que não seja uma palavra reservada da linguagem.

Em um procedimento PL/pgSQL, o $$ é usado para envolver todo o corpo do procedimento, que inclui a declaração de variáveis, a definição de estruturas de controle e qualquer outra lógica que você queira implementar. O primeiro $$ marca o início do corpo do procedimento e o segundo $$ marca o fim do corpo do procedimento.

Outra opção é usar a estrutura “BEGIN ATOMIC” … “END” no lugar de “AS $$“.

O que é PL/pgSQL?

PL/pgSQL é uma linguagem procedural usada no PostgreSQL para escrever stored procedures, triggers e funções. É uma linguagem estruturada em blocos semelhante a outras linguagens procedurais, como PL/SQL no Oracle e T-SQL no Microsoft SQL Server. Essa linguagem fornece estruturas de controle, como instruções IF-THEN-ELSE, LOOP e EXIT, bem como a capacidade de declarar variáveis, realizar tratamento de exceções e usar cursores.

O PL/pgSQL oferece uma interface procedural de alto nível para o banco de dados que permite criar lógica de negócios complexa e automatizar as operações do banco de dados. Por exemplo, podemos usar PL/pgSQL para implementar regras de negócios, validar dados ou realizar cálculos complexos em dados armazenados no banco de dados.

Assim, podemos escrever lógica que pode ser facilmente testada e reutilizada, tornando-a uma maneira eficiente de gerenciar operações de banco de dados.

Trata-se de uma linguagem do lado do servidor, o que significa que o código é executado no servidor de banco de dados, e não no cliente. Isso o torna mais rápido e eficiente do que executar o script do lado do cliente, dentro de uma aplicação de usuário, além de fornecer melhor segurança para seus dados.

Outras opções de linguagens suportadas pelo Postgres incluem SQL padrão e linguagem C, além da possibilidade de trabalhar com extensões para outras linguagens como PL/Python, PL/Perl, etc.

A instrução LANGUAGE plpgsql é necessária ao criar procedimentos armazenados no PostgreSQL porque define a linguagem de programação que será usada para escrever o corpo do procedimento.

Como executar o procedimento armazenado

Podemos chamar um procedimento armazenado no PostgreSQL usando a seguinte sintaxe:

CALL nome_procedimento(arg1_valor, arg2_valor, ...);

Aqui, arg1_valor, arg2_valor, etc. são os valores dos parâmetros passados para o procedimento armazenado. O resultado do procedimento armazenado será retornado na forma de uma tabela.

Vejamos agora alguns exemplos de criação e execução de procedimentos armazenados em PostgreSQL.

Exemplo 01 – Inserir uma linha em uma tabela

Procedimento armazenado em PostgreSQL (somente SQL) que insere uma nova linha em uma tabela, composta por três colunas: nome, sobrenome e idade:

Criar a tabela de teste:

CREATE TABLE pessoas (
    nome varchar(20),
    sobrenome varchar(40),
    idade smallint
);

Vamos a um exemplo de procedimento armazenado em PL/pgSQL que insere uma nova linha em uma tabela com três colunas: nome, sobrenome e idade. O procedimento armazenado usa três parâmetros: p_nome, p_sobrenome e p_idade e insere esses valores na tabela.

CREATE OR REPLACE PROCEDURE cadastra_pessoa(p_nome varchar(20), p_sobrenome varchar(40), p_idade smallint)
  LANGUAGE plpgsql
AS $$
BEGIN
    INSERT INTO pessoas (nome, sobrenome, idade)
    VALUES (p_nome, p_sobrenome, p_idade);
END
$$

Teste

Para executar o procedimento armazenado, basta chamá-lo com os valores desejados como parâmetros, assim:

CALL cadastra_pessoa('Fábio'::varchar, 'dos Reis'::varchar, 48::smallint);

E verificar se a tabela foi atualizada com o novo registro:

SELECT * FROM pessoas;

Especificar tipos de dados na chamada do procedimento

Ao chamar um procedimento armazenado no PostgreSQL, a necessidade de especificar explicitamente os tipos de dados para os argumentos (por exemplo, ‘Fábio’::varchar) geralmente surge devido a questões de desambiguação e coerção de tipos.

Os principais motivos para especificar tipos de dados ao chamar um procedimento armazenado no PostgreSQL são os seguntes:

1. Desambiguação: Quando o PostgreSQL possui múltiplos procedimentos com o mesmo nome, mas com assinaturas diferentes (ou seja, com diferentes tipos de parâmetros ou números de parâmetros), ele precisa saber exatamente qual procedimento deve ser chamado. Especificar o tipo de dado ajuda o PostgreSQL a escolher a versão correta do procedimento.
2. Coerção de Tipos: O PostgreSQL é uma linguagem fortemente tipada, o que significa que cada valor tem um tipo de dado associado, e algumas operações requerem tipos específicos. Quando se passa um literal (como ‘Fábio‘), ele é inicialmente interpretado como um text, a menos que se indique explicitamente um tipo diferente, como o varchar.
3. Prevenção de Erros de Tipagem: Quando o tipo de dado esperado pelo procedimento não corresponde ao tipo inferido pelo PostgreSQL, o banco de dados pode não ser capaz de fazer a coerção automaticamente, resultando em erros. Especificar o tipo assegura que o valor será tratado corretamente.

Exemplo 02 – Inserir um novo produto na tabela

Vamos criar um procedimento armazenado que permita inserir um novo produto na tabela de produtos de nosso banco de dados.

CREATE OR REPLACE PROCEDURE inserir_produto (
    p_cod_produto INT,
    p_nome_produto VARCHAR(30),
    p_descricao TEXT,
    p_preco NUMERIC,
    p_qtde_estoque SMALLINT
)
language plpgsql
AS $$
BEGIN
    INSERT INTO Produtos(cod_produto, nome_produto, descricao, preco, qtde_estoque)
    VALUES (p_cod_produto, p_nome_produto, p_descricao, p_preco, p_qtde_estoque);
    RAISE NOTICE 'Produto % cadastrado com sucesso.', p_nome_produto;
END;
$$;

A instrução RAISE NOTICE emite uma mensagem para o console confirmando a inserção do registro.

Para executar o procedimento:

CALL inserir_produto(4,'Detergente'::varchar,'Detergente neutro 500 ml'::text, 2.35, 2::smallint);

E então podemos verificar se produto foi inserido corretamente realizando uma consulta simples ao banco de dados:

SELECT * FROM Produtos;

Exemplo 03 – Atualizar o preço de um produto.

Este procedimento atualiza o preço de um produto específico, identificado pelo seu código de produto:

CREATE OR REPLACE PROCEDURE atualizar_preco(
    p_cod_produto INT,
    p_novo_preco NUMERIC
)
LANGUAGE plpgsql
AS $$
BEGIN
    UPDATE Produtos
    SET preco = p_novo_preco
    WHERE cod_produto = p_cod_produto;
    RAISE NOTICE 'Preço do produto % atualizado para %', p_cod_produto, p_novo_preco;
END;
$$;

Para executar o procedimento:

CALL atualizar_preco(1, 3.80);

E então podemos verificar se produto teve seu preço corretamente atualizado realizando novamente uma consulta ao banco de dados:

SELECT * FROM Produtos;

Exemplo 04 – Procedimento para consultar produtos com estoque baixo

Este procedimento retorna todos os produtos com quantidade em estoque abaixo de um valor especificado na chamada da procedure.

CREATE OR REPLACE PROCEDURE consultar_estoque_baixo (
    p_limite_estoque INTEGER
)
LANGUAGE plpgsql
AS $$
DECLARE resultado RECORD;
BEGIN
    FOR resultado in
        SELECT cod_produto, nome_produto, qtde_estoque
        FROM Produtos
        WHERE qtde_estoque < p_limite_estoque
    LOOP
        RAISE NOTICE 'Produto: %, Estoque: % ', resultado.nome_produto, resultado.qtde_estoque;
    END LOOP;
END;
$$;

Para executar o procedimento:

CALL consultar_estoque_baixo(3);

Aqui, consultamos todos os produtos cujo estoque está abaixo de 3 unidades.

Devemos notar alguns detalhes interessantes sobre a consulta realizada pelo procedimento armazenado deste exemplo:

Destino dos dados

Quando se usa a instrução SELECT em um procedimento armazenado no PostgreSQL, o resultado deve ser direcionado para algum lugar, como uma variável, uma tabela temporária, ou ser retornado ao chamador da função ou procedimento.

Caso contrário, o PostgreSQL gera a mensagem “consulta não tem destino para os dados resultantes” (no inglês: “query has no destination for result data“).

Se for necessário apenas exibir os resultados no console em um procedimento armazenado, sem retorná-los em uma consulta, podemos usar um loop para iterar sobre os resultados e então exibi-los com RAISE NOTICE.

O tipo RECORD

O tipo RECORD é um tipo de dado genérico no PL/pgSQL que pode acomodar uma linha de dados com colunas de diferentes tipos. Ao contrário de outros tipos de variáveis, que têm um tipo de dado específico (como INTEGER, VARCHAR, etc.), o RECORD pode armazenar qualquer linha inteira de resultado, independentemente de quantas colunas ou de quais tipos de dados essas colunas têm.

A instrução DECLARE r RECORD; em PL/pgSQL é usada para declarar uma variável de tipo RECORD.

Quando usamos o RECORD dentro de um loop FOR IN que itera sobre os resultados de uma consulta, o RECORD é automaticamente “preenchido” com os valores das colunas para cada linha retornada. Isso permite acessar os valores dessas colunas dentro do corpo do loop.

Além disso, uma vez que a linha é armazenada no RECORD, podemos acessar as colunas individuais usando a notação r.coluna, onde r é o nome da variável RECORD e coluna é o nome da coluna que desejamos acessar.

Exemplo 05 – Inserir e atualizar valores no mesmo procedimento.

Exemplo: criar um procedimento armazenado que insira um novo produto na tabela de produtos, ao mesmo tempo em que aplica um desconto percentual especificado a todos os produtos logo após.

CREATE OR REPLACE PROCEDURE insere_atualiza (cod int, prod varchar(30), descr text, valor numeric, qtde smallint, desc_perc numeric)
LANGUAGE plpgsql
AS $$
BEGIN
    INSERT INTO produtos(cod_produto, nome_produto, descricao, preco, qtde_estoque)
    VALUES (cod, prod, descr, valor, qtde);
    UPDATE produtos SET preco = preco * (100 - desc_perc) / 100;
END;
$$;

Executar o procedimento:

CALL insere_atualiza(6,'Alvejante'::varchar(30),'Alvejante de roupas'::text, 12.30, 12::smallint, 10);

Obs.: O tipo numeric geralmente não precisa ser informado (cast) na chamada do procedimento.

Como excluir um procedimento armazenado

Para excluir um procedimento armazenado no PostgreSQL devemos usar a declaração DROP PROCEDURE, como segue:

DROP PROCEDURE nome_procedimento;

Por exemplo, para excluir o procedimento consultar_estoque_baixo:

DROP PROCEDURE consultar_estoque_baixo;

Se houver mais de um procedimento armazenado como mesmo nome, mas com quantidade e tipos de parâmetros distintos (polimorfismo), devemos indicar os tipos de dados dos argumentos ao exclui-lo:

DROP PROCEDURE insere_atualiza(int,varchar,text,numeric,smallint,numeric);

Conclusão

Neste artigo vimos como começar a trabalhar com procedimentos armazenados no PostgreSQL. com alguns exemplos simples de criação de procedures simples. O recurso é muito útil para simplificar código e facilitar a programação de tarefas no banco de dados, principalmente quando as declarações SQL precisam ser executadas a partir de uma aplicação escrita em alguma linguagem de programação para acesso direto dos usuários.

Estudaremos recursos mais avançados de procedimentos armazenados nos próximos artigos, assim como outras formas de programação existentes para bancos de dados PostgreSQL, como Funções e Triggers.

Para saber mais sobre Procedimentos Armazenados no PostgreSQL, assista ao vídeo a seguir da Bóson Treinamentos no YouTube:

O post Procedimentos Armazenados em PostgreSQL (Stored Procedures) apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Uma das regras da normalização de relações em modelagem de dados é que devemos ter apenas valores atômicos nas colunas das tabelas, evitando campos multivalorados. Porém, suponhamos que, por algum motivo qualquer, eu precise armazenar múltiplos dados em uma mesma coluna – por design, complexidade, espaço, desejo do cliente, ou outro motivo qualquer.

Neste caso, uma solução possível seria o emprego de arrays como tipo de dado da coluna.

Um array é uma estrutura de dados homogênea que representa um conjunto de elementos de mesmo tipo. Podemos acessar esses elementos (dados) individuais por meio de uma posição de índice, geralmente numérica. No PostgreSQL essa posição se inicia em 1.

Criar coluna de array no PostgreSQL

A seguir as duas sintaxes empregadas para configurar uma coluna para uso de arrays ao criar uma tabela: a sintaxe padrão do PostgreSQL e na sequência, a sintaxe padrão ANSI SQL. Ambas funcionam no Postgres.

SINTAXE (padrão PostgreSQL):

coluna tipo[]

SINTAXE (padrão ANSI SQL):

coluna tipo ARRAY[tamanho]
ou
coluna tipo ARRAY

O PostgreSQL não impõe restrição de tamanho ao array, mesmo se for especificado. Por padrão, a contagem dos elementos do array inicia em 1, em vez de 0, como é feito na maior parte das linguagens de programação.

Vamos criar uma tabela de exemplo para estudarmos o emprego de arrays em colunas.

Criar tabela com array (sintaxe PostgreSQL)

CREATE TABLE escalaTrabalho (
codFunc smallint,
escala char(3)[]
);

Agora vamos inserir três registros para que possamos rodar algumas consultas de teste na sequência:

Inserir dados na tabela para testes (sintaxe PostgreSQL)

INSERT INTO escalaTrabalho (codFunc, escala)
VALUES
(1,'{"SEG", "TER", "QUA"}'),
(2,'{"QUI", "SEX", "SAB"}),
(3,'{"SEG", "QUA", "SEX"});

Consultas de teste

Vamos testar nossa tabela com algumas consultas aos dados do array da coluna escala.

1. Mostrar todos os dados de escala dos funcionários

SELECT * FROM escalaTrabalho;

2. Retornar a escala de trabalho do funcionário de ID 2

SELECT escala FROM escalaTrabalho
WHERE codFunc = 2;

3. Em qual dia da semana cada funcionário começa a trabalhar?

SELECT codFunc, escala[1] FROM escalaTrabalho;

4. Quais funcionários trabalham às quartas-feiras?

SELECT codFunc FROM escalaTrabalho
WHERE 'QUA' = ANY(escala);
# seguir esta ordem na cláusula where, ou não funcionará.

5. Vamos alterar escala de trabalho do funcionário 3 – ele vai passar a trabalhar às terças, quintas e sábados:

UPDATE escalaTrabalho
SET escala = ARRAY['TER','QUI','SAB']
WHERE codFunc = 3;
# usei a sintaxe padrão ANSI SQL neste exemplo.

Verificamos o resultado com uma consulta simples:

SELECT * FROM escalaTrabalho;

Para saber mais sobre o uso de arrays no PostgreSQL, consulte a documentação Oficial: https://www.postgresql.org/docs/9.0/arrays.html

O post Como usar Arrays em colunas no PostgreSQL apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Uma das tarefas mais corriqueiras no gerenciamento de bancos de dados relacionais é a exclusão de determinados registros (linhas). Por exemplo, podemos excluir um item de uma tabela de produtos que não é mais comercializado por um estabelecimento, ou ainda excluir um cliente que se descadastrou do sistema.

Além disso, em alguns casos, como testes no banco de dados, pode ser necessário excluir todas as linhas de uma tabela de uma vez – ou seja, limpar a tabela.

Podemos excluir registros de uma tabela no PostgreSQL por meio do emprego de duas declarações distintas: as cláusulas DELETE FROM e TRUNCATE TABLE.

Cláusula DELETE FROM

Com a cláusula DELETE FROM apagamos linhas específicas, filtradas por meio de condições especificadas em uma cláusula WHERE

Sintaxe:

DELETE FROM tabela
WHERE coluna operador valor;

Exemplos

Para nossos exemplos de exclusão de registros com DELETE FROM vamos inserir primeiramente mais alguns registros na tabela de produtos de nosso banco de dados de testes:

INSERT INTO produtos (cod_produto,nome_produto,descricao,preco,qtde_estoque)
VALUES
(12,'Sabão em Pó','Caixa de sabão em pó de 1/2 kg',12.50,5),
(13,'Biscoito','Pacote de biscoito integral 110g',3.45,16),
(14,'Manteiga','Pote de manteiga 250g',8.70,5);

Vejamos o conteúdo atual da tabela de produtos:

SELECT * FROM produtos;

1 – Excluir o produto cujo código é igual a 12 da tabela de produtos

DELETE FROM produtos
WHERE cod_produto = 12;

2 – Excluir o produto de nome Manteiga da tabela de produtos

DELETE FROM produtos
WHERE nome_produto = 'Manteiga';

3 – Excluir todos os produtos cuja quantidade em estoque seja igual ou inferior a 5 unidades

DELETE FROM produtos
WHERE qtde_estoque <= 5;

Executamos uma consulta à tabela de produtos para verificar se os registros foram realmente apagados:

SELECT * FROM produtos;

Cláusula TRUNCATE TABLE

Com a cláusula TRUNCATE TABLE podemos excluir  todos os registros de uma tabela em uma única operação, sem no entanto registrar as exclusões de linhas individuais.

Executar a cláusula TRUNCATE TABLE equivale a executar uma instrução DELETE FROM, porém sem o emprego de condições de filtragem com a cláusula WHERE. Deste modo, TRUNCATE TABLE é empregada para excluir completamente o conteúdo de uma tabela no PostgreSQL.

Porém, a cláusula TRUNCATE TABLE tem maior performance que a declaração DELETE FROM, sendo mais rápida, utilizando menos recursos de sistema e log de transações durante sua execução.

Exemplo de TRUNCATE TABLE

Vamos a um exemplo. Primeiramente, visualizamos o conteúdo da tabela de pedidos de nosso banco de dados de testes:

SELECT * FROM pedidos;

Executamos agora TRUNCATE TABLE para apagar o conteúdo deste tabela:

TRUNCATE TABLE pedidos;

Conferimos se a tabela está limpa:

SELECT * FROM pedidos;

Todo o conteúdo da tabela foi excluído, mas a tabela continua existindo no banco de dados. Vamos agora inserir novos registros nesta tabela com a declaração INSERT INTO, pois a vamos utilizar nas pŕoximas lições de nosso curso de PostgreSQL:

INSERT INTO pedidos (cod_cliente, cod_produto, qtde)
VALUES
(1,2,3),
(2,3,2),
(1,3,4),
(2,6,3),
(2,5,2),
(3,8,5);

Finalmente, conferimos se esses novos registros foram inseridos corretamente na tabela de pedidos:

SELECT * FROM pedidos;

É isso aí!

O post Excluir Registros no PostgreSQL – DELETE e TRUNCATE TABLE apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Com a cláusula ORDER BY no PostgreSQL podemos realizar a ordenação dos resultados retornados em uma consulta, tanto em ordem crescente quanto em ordem decrescente (alfabética, por data ou numérica). 

Sintaxe

SELECT colunas
FROM tabela
[WHERE condições]
ORDER BY coluna, coluna ASC | DESC
[NULLS FIRST | LAST]

Opções NULLS FIRST | LAST

Essas duas opções são usadas para determinar se eventuais valores nulos presentes no resultado da consulta devem ser mostrados antes ou depois dos valores não-nulos.

Exemplos

Para nossos exemplos vamos inserir alguns registros novos em uma tabela de cadastro de produtos de nosso banco de dados de testes. Com a declaração INSERT INTO a seguir podemos criar cinco linhas novas nesta tabela:

INSERT INTO produtos(cod_produto,nome_produto,descricao,preco,qtde_estoque)
VALUES
(6,'Detergente','Detergente líquido 500 ml',1.89,32),
(7,'Leite Integral','Leite Integral caixa de 1 litro',4.60,70),
(8,'Refrigerante','Garrafa de refrigerante de 600 ml',3.70,14),
(9,'Refrigerante','Garrafa de refrigerante de 1 litro',6.89,16),
(10,'Refrigerante','Lata de refrigerante de 350 ml',2.99,45);

Também vamos inserir um registro na tabela de produtos sem no entanto especificar sua descrição. Assim poderemos testar posteriormente a opção NULLS FIRST | LAST em nossos exemplos:

INSERT INTO produtos(cod_produto,nome_produto,preco,qtde_estoque)
VALUES (11,'Margarina',3.20,8);

Vejamos agora alguns exemplos de emprego da cláusula ORDER BY em consultas SQL.

Exemplos

1 – Retornar todos os dados da tabela de produtos, ordenados em ordem crescente de nome de produto.

SELECT * FROM Produtos
ORDER BY nome_produto;

2 – Vamos retornar novamente todos os dados da tabela de produtos, porém agora ordenados pela quantidade em estoque em ordem decrescente (predicado DESC).

SELECT * FROM Produtos
ORDER BY qtde_estoque DESC;

3 – Obtemos os nomes de produtos e seus respectivos preços, ordenados por nome de produto (ordem alfabética)

SELECT nome_produto, preco
FROM Produtos
ORDER BY nome_produto;

4 – O mesmo que o exemplo #3, porém agora vamos ordenar primeiro por nome de produto, e então por preço para cada produto que aparecer mais de uma vez no resultado (em ordem crescente)

SELECT nome_produto, preco
FROM Produtos
ORDER BY nome_produto, preco;

5 – Vamos retornar os nomes dos produtos com suas descrições, ordenados por descrição.

SELECT nome_produto, descricao
FROM produtos
ORDER BY descricao;

Note que há valores nulos (NULL) no resultado da consulta, e perceba onde eles aparecem.

6 – Agora vamos obter novamente os nomes dos produtos com suas descrições, ordenados por descrição, porém colocando os valores nulos no início da tabela de resultados (opção NULLS FIRST).

SELECT nome_produto, descricao
FROM produtos
ORDER BY descricao NULLS FIRST;

7 – Finalmente, vamos obter os nomes dos produtos com seus preços, ordenados por preço em ordem decrescente (do mais caro para o mais barato), porém somente dos produtos que custem mais do que R$ 10,00 (filtro com cláusula WHERE).

SELECT nome_produto, preco
FROM produtos
WHERE preco > 10.00
ORDER BY preco DESC;

É isso aí!

O post Como ordenar consultas com cláusula ORDER BY no PostgreSQL apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Neste artigo vamos tratar dos Operadores de Comparação em PostgreSQL, também conhecidos como Operadores Relacionais. Os operadores de comparação, como o próprio nome diz, comparam dois valores em uma consulta SQL e então retornam um valor do tipo booleano (verdadeiro ou falso), que pode ser utilizado para refinar um filtro de consulta com a cláusula WHERE, por exemplo.

Os operadores de comparação disponíveis em PostgreSQL são os seguintes:

Além desses operadores padrão, também está disponível o operador especial BETWEEN, que será estudado na próxima lição.

Vejamos alguns exemplos de aplicação dos operaores relacionais no PostgresSQL.

Exemplos

1 – Retornar os nomes e preços dos produtos que custem mais do que R$ 12,00.

SELECT nome_produto, preco
FROM produtos
WHERE preco > 12.00;

2 – Obter os nomes dos produtos e as quantidades em estoque, dos produtos cuja quantidade no estoque seja igual ou inferior a 20 unidades.

SELECT nome_produto, qtde_estoque
FROM produtos
WHERE qtde_estoque <= 20;

3 – Retornar os nomes do produtos e a quantidade deles no estoque, porém somente dos produtos cuja quantidade no estoque seja maior do que 10 unidade e menor ou igual a 20 unidades (ou seja, um intervalo de valores do tipo ]10, 20]).

SELECT nome_produto, qtde_estoque
FROM produtos
WHERE qtde_estoque <= 20
AND qtde_estoque > 10;

Note que neste exemplo conectamos duas expressões de comparação por meio da palavra-chave AND, que na verdade também é um operador – no caso, um operador lógico.

4 – Obter os nomes dos produtos e a quantidade armazenada no estoque, de todos os produtos exceto do produto de nome Refrigerante.

SELECT nome_produto, qtde_estoque
FROM produtos
WHERE nome_produto != 'Refrigerante';

É isso aí! Na próxima lição vamos estudar o operador BETWEEN (e NOT BETWEEN), que permite refinar ainda mais as comparações em consultas SQL.

Até mais!

O post Operadores de Comparação em PostgreSQL apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Em nossa última aula vimos como criar consultas SQL simples com o uso da cláusula SELECT no PostgreSQL. Porém, como pudemos perceber, os resultados que eram retornados traziam todas as linhas de uma tabela, ou seja, todos os registros presentes – porém, nem sempre é isso o que desejamos.

Na verdade, muito provavelmente o que queremos como retorno ao realizar uma consulta SQL é obter informações sobre um registro ou um grupo de registros específicos, e não todo o conteúdo de uma tabela.

Com o emprego da cláusula WHERE no PostgreSQL podemos filtrar o conjunto de registros retornados no resultado de uma consulta, de modo a obter apenas as informações relevantes (e não o conteúdo completo das colunas).

Sintaxe:

SELECT coluna(s)
FROM tabela 
WHERE condição de filtragem;

Na prática, podemos usar uma série de operadores de comparação para determinar a condição de filtragem com a cláusula WHERE, sendo o mais comum o sinal de igualdade (=). Também é possível usar sinais de > (maior que), < (menor que), >= (maior ou igual a) e <= (menor ou igual a).

Vejamos alguns exemplos da aplicação da cláusula WHERE para filtrar os resultados de consultas SQL simples.

Exemplo 01 – Retornar nome e sobrenome do autor cujo ID é igual a 3:

SELECT Nome_Autor, Sobren_Autor
FROM tbl_autores
WHERE id_autor = 3;

Exemplo 02 – Retornar nomes, datas de publicação e preços dos livros que custem mais do que R$ 60,00:

SELECT Nome_Livro, Data_Pub, Preco_Livro
FROM tbl_livros
WHERE Preco_Livro > CAST(60.00 AS MONEY);

Neste exemplo usamos a função CAST() para converter o tipo de dado informado na condição de filtragem da cláusula WHERE (que é NUMERIC) para o tipo de dado armazenado na coluna (que foi criada com tipo MONEY), de modo a obter êxito ao realizar a consulta. Vamos estudar as funções de conversão de tipos de dados no PostgreSQL mais adiante em nosso curso.

Exemplo 03: Retornar data de publicação e preço do livro de nome Using Samba:

SELECT Nome_Livro, Data_Pub, Preco_Livro
FROM tbl_livros
WHERE Nome_Livro = 'Using Samba';

Note que englobamos o nome do livro entre aspas simples, pois se trata de uma consulta usando uma string de texto como filtro.

Exemplo 04: Retornar nomes e datas de publicação dos livros publicados antes de 01/01/2010:

SELECT Nome_Livro, Data_Pub
FROM tbl_livros
WHERE Data_Pub <= '20100101';

Também neste exemplo devemos englobar o filtro da consulta, que é uma data, entre aspas.

Podemos aprimorar os filtros aplicados às consultas com o emprego de cláusulas adicionais em conjunto com a cláusula WHERE. E isso é o que faremos a partir da próxima lição.

Até mais!

Anterior: Realizando consultas simples no PostgreSQL com declaração SELECT

O post Como filtrar consultas com cláusula WHERE no PostgreSQL apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Sem dúvida, uma das tarefas mais importantes e comuns que realizamos em bancos de dados PostgreSQL (e outros), tanto do ponto de vista do usuário quanto do desenvolvedor / DBA, é efetuar consultas (queries) nos dados armazenados nas tabelas. A declaração SQL básica que empregados para realizar essas consultas é a declaração SELECT.

Neste tutorial veremos como usar o SELECT para realizar consultas simples em tabelas únicas de um banco PostgreSQL.

Comando SELECT

A sintaxe do SELECT é a seguinte:

SELECT coluna(s) FROM tabela;

Onde coluna(s) indica uma ou mais colunas cujos valores devem ser retornados pela consulta, e tabela se refere à tabela que está sendo consultada.

Exemplos

1 – Vamos consultar os nomes dos autores que estão cadastrados na tabela de autores:

SELECT Nome_Autor FROM tbl_autores;

2 – Agora vamos consultar todos os dados da tabela de autores (podemos empregar o caractere curinga * para indicar que queremos que todas as colunas sejam retornadas):

SELECT * FROM tbl_autores;

Note que a coluna data_Nasc tem todos os dados como [null], pois essas informações não foram inseridas ao cadastrar os autores. Aprenderemos como inserir esses dados na aula de atualização de registros , com a declaração UPDATE.

3 – Consultar os nomes dos livros presentes na tabela de livros:

SELECT Nome_Livro FROM tbl_livros;

4 – Consultar os gêneros já cadastrados na tabela de gêneros (assuntos):

SELECT Nome_Genero FROM tbl_generos;

5 – Consultar os nomes de livros e IDs de seus respectivos autores presentes na tabela de livros:

SELECT Nome_Livro, Autor FROM tbl_livros;

6 – Consultar os nomes dos livros, seus preços e datas de publicação, presentes na tabela de livros:

SELECT Nome_Livro, Preco_Livro, Data_Pub
FROM tbl_livros;

É isso aí! Na próxima lição vamos começar a incrementar nossas consultas SQL usando declarações adicionais como filtros e comandos de ordenação. Até!

O post Consultas simples em tabelas – a declaração SELECT no PostgreSQL apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Após criar as tabelas com seus relacionamentos, como fizemos na lição passada, estamos prontos para começar a inserir dados no banco (registros). Para tal empregamos o comando SQL INSERT INTO.

Sintaxe padrão:

INSERT INTO nome_tabela (coluna1, coluna2,...)
VALUES (valor1, valor2,...);

Conforme a sintaxe mostrada, especificamos a tabela e quais colunas dessa tabela irão armazenar os dados, e na sequencia, logo após a palavra-chave VALUES, especificamos os dados em si – rigorosamente na mesma ordem em que as colunas foram listadas no comando.

Se houver uma coluna usando auto incremento (SERIAL), ela não deve ser incluída na listagem de colunas do comando, pois seus dados numéricos serão gerados e inseridos automaticamente pelo PostgreSQL toda vez que um novo registro for adicionado.

Inserir novos registros em tabelas

No artigo passado nós criamos quatro tabelas para nosso banco db_Biblioteca, as tabelas de Autores, Editoras, Gêneros e Livros.. Vamos inserir dados (registros) nessas tabelas agora, usando para isso o comando INSERT INTO.

Tabela de Editoras

Vamos cadastrar cinco editoras na tabela de editoras, usando comandos INSERT INTO discretos (separados):

INSERT INTO tbl_editoras (ID_Editora, Nome_Editora) VALUES (1,'Prentice Hall');
INSERT INTO tbl_editoras (ID_Editora, Nome_Editora) VALUES (2,'O´Reilly');
INSERT INTO tbl_editoras (ID_Editora, Nome_Editora) VALUES (3,'Microsoft Press');
INSERT INTO tbl_editoras (ID_Editora, Nome_Editora) VALUES (4,'Wiley');
INSERT INTO tbl_editoras (ID_Editora, Nome_Editora) VALUES (5,'McGraw-Hill Education');

Executamos o comando de inserção cinco vezes, uma para cada registro inserido. Esta forma não é a mais performática, e faremos de outra maneira nas próximas tabelas.

Tabela de Autores

Agora cadastraremos 14 autores na tabela de autores. Vamos usar uma forma simplificada da sintaxe do comando INSERT INTO, na qual executamos o comando apenas uma vez, passando todos os registros (linhas) separados por uma vírgula:

INSERT INTO tbl_autores
VALUES
(1, 'Daniel', 'Barret'),
(2, 'Gerald', 'Carter'),
(3, 'Mark', 'Sobell'),
(4, 'William', 'Stanek'),
(5, 'Richard', 'Blum'),
(6, 'Jostein', 'Gaarder'),
(7, 'Umberto', 'Eco'),
(8, 'Neil', 'De Grasse Tyson'),
(9, 'Stephen', 'Hawking'),
(10, 'Stephen', 'Jay Gould'),
(11, 'Charles', 'Darwin'),
(12, 'Alan', 'Turing'),
(13, 'Simon', 'Monk'),
(14, 'Paul', 'Scherz');

Tabela de Gêneros

Vamos cadastrar 10 gêneros na tabela de gêneros:

INSERT INTO tbl_generos
VALUES
(1, 'Tecnologia'),
(2, 'História'),
(3, 'Literatura'),
(4, 'Astronomia'),
(5, 'Botânica'),
(6, 'Geografia'),
(7, 'Matemática'),
(8, 'Química'),
(9, 'Engenharia'),
(10, 'Ficção Científica');

Tabela de Livros

Finalmente, vamos inserir 7 livros na tabela de livros. Note que não é preciso informar um código (ID) para os livros, pois esta coluna foi criada como auto-incremento (SERIAL).

INSERT INTO tbl_livros (Nome_Livro, Data_Pub, Preco_Livro, Genero, Autor, Editora)
VALUES
('Linux Command Line and Shell Scripting', '20150109', 68.35, 1, 5, 4),
('SSH, the Secure Shell', '20050517', 58.30, 1, 1, 2),
('Using Samba', '20031221', 61.45, 1, 2, 2),
('Fedora and Red Hat Linux', '20140110', 62.24, 1, 3, 1),
('Windows Server 2012 Inside Out', '20130125', 66.80, 1, 4, 3),
('Microsoft Exchange Server 2010', '20101201', 45.30, 1, 4, 3),
('Practical Electronics for Inventors', '20160324', 67.80, 1, 13, 5);

Após a execução desses comandos, devemos ter registros inseridos nas quatro tabelas de nosso banco de dados. Se ocorreu algum erro, revise o código que vocÊ digitou – geralmente, se trata de algo simplório, como uma vírgula faltando ou parêntese não fechado. De qualquer maneira, precisamos agora conferir se os dados foram cadastrados corretamente.

É o que faremos na sequência.

Testar a inserção de dados

Vamos executar os comandos a seguir, que são consultas simples usando a cláusula SQL SELECT, para verificar se os registros foram inseridos de forma correta nas tabelas do banco de dados no PostgreSQL:

SELECT * FROM tbl_autores;
SELECT * FROM tbl_editoras;
SELECT * FROM tbl_livros;
SELECT * FROM tbl_generos;

Veja o resultado da inserção de dados na tabela de livros, verificado com o comando executado acima:

Dados inseridos com sucesso na tabela!

Na próxima lição vamos aprender a realizar consultas simples usando o comando SELECT, que empregamos para testar o cadastro de dados na tabela aqui. Até!

O post Como inserir dados em tabelas no PostgreSQL com INSERT INTO apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Uma das operações mais comuns que realizamos ao trabalhar com bancos de dados no PostgreSQL é justamente realizar a verificação dos bancos de dados e respectivas tabelas existentes no sistema. Para tal podemos usar alguns comandos simples do psql, os quais nos irão retornar dados importantes como:

• Nomes dos bancos de dados
• Proprietários dos objetos
• Tipo de codificação do banco
• Colação (Collate)
• Privilégios de acesso
• Banco de dados conectado atualmente
• Esquemas
• Nomes das tabelas e seus proprietários

Entre outras.

Para que possamos visualizar os bancos de dados no postgres (e também suas tabelas), o primeiro passo será nos logarmos no utilitário psql via prompt de comandos (Windows) ou terminal (Linux / macOS) com um usuário válido, e então executamos os comandos que serão mostrados a seguir.

Listar os bancos existentes no postgres

Para listar os bancos de dados existentes no postgres usamoso comando \l:

\l

Note que meu sistema possui diversos bancos de dados, cujos nomes são exibidos na primeira coluna à esquerda dos resultados. As demais colunas trazem informações adicionais sobre cada banco.

Podemos determinar o banco conectado atualmente com o comando a seguir:

SELECT current_database();

Meu banco conectado atualmente (selecionado) é o banco de nome fabio. Podemos conectar a um outro banco de dados usando a sintaxe a seguir:

\c nome_do_banco //conecta com usuário atual
//ou
\c nome_do_banco nome_outro_usuário //conecta com outro usuário ao banco

Por exemplo, para conectar ao banco de nome “kiki”:

\c kiki

Também podemos ver informações a respeito da conexão atual, como o nome do banco de dados em uso e o usuário conectado, além da porta de conexão empregada, com o comando conninfo:

\conninfo

Listar tabelas de banco de dados no PostgreSQL

Para listar as tabelas existentes no banco conectado, usamos os comandos do psql \d ou \dt:

\dt
// ou
\d

Como o banco conectado atualmente ainda não possui nenhuma tabela criada, vamos criar uma tabela no postgres e depois executaremos novamente o comando \d para verificar se a tabela foi criada com sucesso.

Para criar uma tabela de exemplo, contendo dois campos (id e valor), vamos empregar a seguinte declaração SQL:

CREATE TABLE teste (
id int PRIMARY KEY,
valor int);

Digite a declaração como está no prompt do psql, não esquecendo de colocar o ponto-e-vírgula no final – esse caractere é que diz ao psql que a declaração finalizou e deve ser executada ao pressionar enter.

Deve aparecer a mensagem “CREATE TABLE” se nenhum erro ocorrer.

Vamos listar agora a tabela criada no banco atual:

\dt

Note que este comando nos informa o nome do esquema, tipo do objeto (tabela), os nomes das tabelas e seus respectivos donos (proprietários). No caso, é informado o nome da tabela que criamos anteriormente – teste – e seu respectivo proprietário, que é o usuário fabio.

Veja também: Como criar um banco de dados no PostgreSQL com comando createdb

O post Como listar Bancos de Dados e Tabelas no PostgreSQL apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

No PostgreSQL existe um tipo especial de objeto de banco de dados chamado de Sequência, que permite gerar, como o nome diz, uma sequência de números inteiros. Usamos esse objeto, normalmente, para gerar valores em um campo de chave primária de forma automatizada. Assim, podemos criar um campo de auto-incremento no PostgreSQL.

Para tal, usamos a palavra-chave SERIAL (que é um pseudo-tipo) ao criarmos uma tabela, para identificar a coluna que receberá os valores sequenciais.

Ao usarmos a palavra-chave SERIAL, o PostgreSQL irá criar um objeto de sequência e configurar o próximo valor numérico gerado como valor padrão da coluna em si. Além disso, a restrição NOT NULL é adicionada automaticamente à coluna, pois ela sempre terá um valor associado.

Além do pseudo-tipo SERIAL, o PostgreSQL também possui outros pseudo-tipos para geração de sequências, como o SMALLSERIAL e BIGSERIAL. A tabela a seguir mostra as características de cada um desses pseudo-tipos:

Exemplo

Vejamos um exemplo de emprego de sequência de auto-incremento.

CREATE TABLE Funcionarios (
 IdFunc SERIAL PRIMARY KEY,
 NomeFunc VARCHAR(60),
 DescrCargo TEXT
);

A coluna IdFunc é a coluna que receberá dados numéricos sequenciais, por conta do emprego da palavra SERIAL.

Testando

Para testar o auto-incremento vamos inserir alguns registros na tabela de funcionários criada anteriormente. Note que não devemos inserir dados na coluna IdFunc, pois seus valores serão gerados automaticamente para cada registro inserido.

INSERT INTO Funcionarios (NomeFunc, DescrCargo)
VALUES
('Fábio','CEO da Bóson Treinamentos em Tecnologia'),
('Sandra','Diretora da Okinawa Foods'),
('Ana','Relações Públicas do jornal Diário do Naturalista);

Para ver o resultado, basta realizar uma consulta simples aos dados da tabela:

SELECT * FROM Funcionarios;

Resultado:

Note os valores sequenciais na coluna idFunc, criados automaticamente.

Se acrescentarmos a cláusula RETURNING ao inserir linhas na tabela, será retornado o valor gerado na coluna de auto incremento, como no exemplo a seguir:

INSERT INTO Funcionarios (NomeFunc, DescrCargo)
VALUES
('Monica','Pesquisadora de Novas Tecnologias na Bóson Treinamentos')
RETURNING IdFunc;

Resultado:

Note que ao inserir o novo registro é exibido na saída de dados o valor da coluna de auto-incremento que foi gerado – no caso, o número 4. Se realizarmos uma nova consulta à tabela veremos esse valor associado ao novo registro:

SELECT * FROM Funcionarios;

É isso aí! Mostramos nesta lição como criar uma coluna de auto-incremento em PostgreSQL usando SERIAL. Falaremos mais sobre outros tipos de sequências em ma próxima lição.

Até mais!

Anterior: Como criar tabelas no PostgreSQL com CREATE TABLE

O post Auto-incremento no PostgreSQL com SERIAL apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.