PostgreSQL
 sql >> Base de Dados >  >> RDS >> PostgreSQL

Como filtrar os resultados da consulta no PostgreSQL


Introdução


Para trabalhar com dados em um banco de dados, você precisa ser capaz de recuperar e direcionar registros específicos de forma eficaz. Ao usar cláusulas de filtragem em suas consultas, você pode adicionar critérios específicos para retornar apenas os registros mais relevantes.

Neste guia, veremos algumas das operações de filtragem mais comuns disponíveis no PostgreSQL e demonstraremos como usá-las para restringir o foco de suas instruções. Mostraremos como testar as características em registros individuais com WHERE cláusulas, como agrupar registros para resumir informações com GROUP BY , como filtrar grupos de registros com o HAVING subcláusula e como definir o número máximo de linhas retornadas com o LIMIT cláusula.


Usando o WHERE cláusula para definir critérios de correspondência


Uma das maneiras mais comuns e amplamente úteis de indicar seus requisitos de consulta é WHERE cláusula. O WHERE A cláusula permite definir critérios de pesquisa reais para instruções de consulta especificando condições que devem ser verdadeiras para todos os registros correspondentes.

WHERE As cláusulas funcionam definindo expressões booleanas que são verificadas em cada linha de dados candidata. Se o resultado da expressão for falso, a linha será removida dos resultados e não será retornada ou continuará para o próximo estágio de processamento. Se o resultado da expressão for verdadeiro, ela atende aos critérios da pesquisa e continuará para qualquer processamento adicional como uma linha candidata.

A sintaxe básica do WHERE cláusula fica assim:
SELECT * FROM my_table WHERE <condition>;

O <condition> pode ser qualquer coisa que resulte em um valor booleano. No PostgreSQL, um valor booleano é qualquer TRUE , FALSE , ou NULL .

As condições geralmente são formadas usando um ou mais dos seguintes operadores:
  • = :igual a
  • > :maior que
  • < :menor que
  • >= :maior ou igual a
  • <= :menor ou igual a
  • <> ou != :não igual
  • AND :o operador lógico "and" — une duas condições e retorna TRUE se ambas as condições forem TRUE
  • OR :operador lógico "ou" — une duas condições e retorna TRUE se pelo menos uma das condições for TRUE
  • IN :o valor está contido na lista, série ou intervalo que segue
  • BETWEEN :o valor está contido no intervalo dos valores mínimo e máximo que seguem, inclusive
  • IS NULL :corresponde se o valor for NULL
  • NOT :nega o valor booleano que segue
  • EXISTS :a consulta a seguir contém resultados
  • LIKE :corresponde a um padrão (usando os curingas % para corresponder a 0 ou mais caracteres e _ para corresponder a um único caractere)
  • ILIKE :corresponde a um padrão (usando os curingas % para corresponder a 0 ou mais caracteres e _ para corresponder a um único caractere), não diferencia maiúsculas de minúsculas
  • SIMILAR TO :corresponde a um padrão usando o dialeto de expressão regular do SQL
  • ~ :corresponde a um padrão usando expressões regulares POSIX, diferencia maiúsculas de minúsculas
  • ~* :corresponde a um padrão usando expressões regulares POSIX, não diferencia maiúsculas de minúsculas
  • !~ :não corresponde a um padrão usando expressões regulares POSIX, diferencia maiúsculas de minúsculas
  • !~* :não corresponde a um padrão usando expressões regulares POSIX, não diferencia maiúsculas de minúsculas

Embora a lista acima represente algumas das construções de teste mais comuns, existem muitos outros operadores que produzem resultados booleanos que podem ser usados ​​em conjunto com um WHERE cláusula.

Exemplos usando WHERE


Uma das verificações mais comuns e diretas é para igualdade, usando o = operador. Aqui, verificamos se cada linha no customer tabela tem um last_name valor igual a Smith :
SELECT * FROM customer WHERE last_name = 'Smith';

Podemos adicionar condições adicionais a isso para criar expressões compostas usando operadores lógicos. Este exemplo usa o AND cláusula para adicionar um teste adicional em relação ao first_name coluna. As linhas válidas devem atender às duas condições fornecidas:
SELECT * FROM customer WHERE first_name = 'John' AND last_name = 'Smith';

Da mesma forma, podemos verificar se alguma de uma série de condições foi atendida. Aqui, verificamos as linhas do address tabela para ver se o zip_code valor é igual a 60626 ou o neighborhood coluna é igual à string "Roger's Park". Usamos duas aspas simples para indicar que uma aspa simples literal deve ser pesquisada:
SELECT * FROM address WHERE zip_code = '60626' OR neighborhood = 'Roger''s Park';

O IN O operador pode funcionar como uma comparação entre vários valores, entre parênteses. Se houver uma correspondência com qualquer um dos valores fornecidos, a expressão será TRUE :
SELECT * FROM customer WHERE last_name IN ('Smith', 'Johnson', 'Fredrich');

Aqui, verificamos um padrão de string usando LIKE . O % funciona como um curinga que corresponde a zero ou mais caracteres, portanto, "Pete", "Peter" e qualquer outra string que comece com "Pete" corresponderia:
SELECT * FROM customer WHERE last_name LIKE 'Pete%';

Poderíamos fazer uma pesquisa semelhante usando o ~* operador para verificar correspondências usando expressões regulares POSIX sem considerar maiúsculas e minúsculas. Neste caso, verificamos se o valor de last_name começa com um "d" e contém a substring "on", que corresponderia a nomes como "Dickson", "Donald" e "Devon":
SELECT * FROM customer WHERE last_name ~* '^D.*on.*';

Podemos verificar se um número de rua está dentro do bloco 4000 de endereços usando o BETWEEN e AND operadores para definir um intervalo inclusivo:
SELECT * FROM address WHERE street_number BETWEEN 4000 AND 4999;

Aqui, podemos exibir qualquer customer entradas que tenham números de segurança social que não tenham 9 dígitos. Usamos o LENGTH() operador para obter o número de dígitos no campo e o <> para verificar a desigualdade:
SELECT * FROM customer WHERE LENGTH(SSN) <> 9;



Usando o GROUP BY cláusula para resumir vários registros


O GROUP BY A cláusula é outra maneira muito comum de filtrar resultados representando vários resultados com uma única linha. A sintaxe básica do GROUP BY cláusula fica assim:
SELECT <columns> FROM some_table GROUP BY <columns_to_group>

Quando um GROUP BY é adicionada a uma instrução, ela diz ao PostgreSQL para exibir uma única linha para cada valor exclusivo para a(s) coluna(s) fornecida(s). Isso tem algumas implicações importantes.

Como o GROUP BY cláusula é uma forma de representar várias linhas como uma única linha, o PostgreSQL só pode executar a consulta se puder calcular um valor para cada uma das colunas que tem a tarefa de exibir. Isso significa que cada coluna identificada pelo SELECT parte da declaração deve ser:
  • incluído no GROUP BY cláusula para garantir que cada linha tenha um valor único
  • resumido para resumir todas as linhas dentro de cada grupo

Praticamente falando, isso significa que qualquer coluna no SELECT lista não incluída no GROUP BY A cláusula deve usar uma função agregada para produzir um único resultado para a coluna de cada grupo.

Exemplos usando GROUP BY


Para os exemplos desta seção, suponha que temos uma tabela chamada pet que definimos e preenchemos assim:
CREATE TABLE pet (    id SERIAL PRIMARY KEY,    type TEXT,    name TEXT,    color TEXT,    age INT);INSERT INTO pet (type, name, color, age) VALUES('dog', 'Spot', 'brown', 3),('dog', 'Rover', 'black', 7),('dog', 'Sally', 'brown', 1),('cat', 'Sabrina', 'black', 8),('cat', 'Felix', 'white', 4),('cat', 'Simon', 'orange', 8),('rabbit', 'Buttons', 'grey', 4),('rabbit', 'Bunny', 'brown', 8),('rabbit', 'Briony', 'brown', 6);

O uso mais simples de GROUP BY é exibir o intervalo de valores exclusivos para uma única coluna. Para fazer isso, use a mesma coluna em SELECT e GROUP BY . Aqui, vemos todas as cores usadas na tabela:
SELECT color FROM pet GROUP BY color;
 
 color-------- black grey brown white orange(5 rows)

À medida que você vai além de uma única coluna no SELECT lista de colunas, você deve adicionar as colunas ao GROUP BY cláusula ou use uma função de agregação para produzir um único valor para o grupo de linhas que está sendo representado.

Aqui, adicionamos type para o GROUP BY cláusula, o que significa que cada linha representará uma combinação única de type e color valores. Também adicionamos a age coluna, resumida pelo avg() função para encontrar a idade média de cada um dos grupos:
SELECT type, color, avg(age) AS average_age FROM pet GROUP BY type, color;
 
  type  | color  |     average_age--------+--------+-------------------- rabbit | brown  | 7.0000000000000000 cat    | black  | 8.0000000000000000 rabbit | grey   | 4.0000000000000000 dog    | black  | 7.0000000000000000 dog    | brown  | 2.0000000000000000 cat    | orange | 8.0000000000000000 cat    | white  | 4.0000000000000000(7 rows)

Funções agregadas funcionam tão bem com uma única coluna no GROUP BY cláusula. Aqui, encontramos a idade média de cada tipo de animal:
SELECT type, avg(age) AS average_age FROM PET GROUP BY type;
 
  type  |     average_age--------+-------------------- rabbit | 6.0000000000000000 dog    | 3.6666666666666667 cat    | 6.6666666666666667(3 rows)

Se quisermos exibir o mais antigo de cada tipo de animal, podemos usar o max() função na age coluna. O GROUP BY cláusula recolhe os resultados nas mesmas linhas de antes, mas a nova função altera o resultado na outra coluna:
SELECT type, max(age) AS oldest FROM pet GROUP BY type;
 
  type  | oldest--------+------- rabbit |     8 dog    |     7 cat    |     8(3 rows)



Usando o HAVING cláusula para filtrar grupos de registros


O GROUP BY A cláusula é uma maneira de resumir dados ao recolher vários registros em uma única linha representativa. Mas e se você quiser restringir esses grupos com base em fatores adicionais?

O HAVING cláusula é um modificador para o GROUP BY cláusula que permite especificar as condições que cada grupo deve satisfazer para ser incluído nos resultados.

A sintaxe geral fica assim:
SELECT <columns> FROM some_table GROUP BY <columns_to_group> HAVING <condition>

A operação é muito semelhante ao WHERE cláusula, com a diferença sendo que WHERE filtra registros únicos e HAVING filtra grupos de registros.

Exemplos usando HAVING


Usando a mesma tabela que apresentamos na última seção, podemos demonstrar como o HAVING cláusula funciona.

Aqui, agrupamos as linhas do pet tabela por valores únicos no type coluna, encontrando o valor mínimo de age também. O HAVING A cláusula filtra os resultados para remover quaisquer grupos em que a idade não seja maior que 1:
SELECT type, min(age) AS youngest FROM pet GROUP BY type HAVING min(age) > 1;
 
  type  | youngest--------+---------- rabbit |        4 cat    |        4(2 rows)

Neste exemplo, agrupamos as linhas em pet pela sua cor. Em seguida, filtramos os grupos que representam apenas uma única linha. O resultado nos mostra todas as cores que aparecem mais de uma vez:
SELECT color FROM pet GROUP BY color HAVING count(color) > 1;
 
 color------- black brown(2 rows)

Podemos realizar uma consulta semelhante para obter as combinações de type e color que apenas um único animal tem:
SELECT type, color FROM pet GROUP BY type, color HAVING count(color) = 1;
 
  type  | color--------+-------- cat    | black rabbit | grey dog    | black cat    | orange cat    | white(5 rows)



Usando o LIMIT cláusula para definir o número máximo de registros


O LIMIT cláusula oferece uma abordagem diferente para reduzir os registros que sua consulta retorna. Em vez de eliminar linhas de dados com base em critérios dentro da própria linha, o LIMIT A cláusula define o número máximo de registros retornados por uma consulta.

A sintaxe básica de LIMIT se parece com isso:
SELECT * FROM my_table LIMIT <num_rows> [OFFSET <num_rows_to_skip>];

Aqui, o <num_rows> indica o número máximo de linhas a serem exibidas da consulta executada. Isso é frequentemente usado em conjunto com ORDER BY cláusulas para obter as linhas com os valores mais extremos em uma determinada coluna. Por exemplo, para obter as cinco melhores pontuações em um exame, um usuário pode ORDER BY uma score coluna e, em seguida, LIMIT os resultados para 5.

Enquanto LIMIT conta a partir do topo dos resultados por padrão, o opcional OFFSET palavra-chave pode ser usada para compensar a posição inicial que ela usa. Na verdade, isso permite paginar os resultados exibindo o número de resultados definidos por LIMIT e, em seguida, adicionando o LIMIT número para o OFFSET para recuperar a página seguinte.

Exemplos usando LIMIT


Usaremos o pet tabela anterior para os exemplos nesta seção.

Como mencionado acima, LIMIT é frequentemente combinado com um ORDER BY cláusula para definir explicitamente a ordem das linhas antes de fatiar o número apropriado. Aqui, classificamos o pet entradas de acordo com sua age , do mais velho ao mais novo. Em seguida, usamos LIMIT para exibir os 5 animais mais antigos:
SELECT * FROM pet ORDER BY age DESC LIMIT 5;
 
  type  |  name   | color  | age | id--------+---------+--------+-----+---- cat    | Simon   | orange |   8 |  6 cat    | Sabrina | black  |   8 |  4 rabbit | Bunny   | brown  |   8 |  8 dog    | Rover   | black  |   7 |  2 rabbit | Briany  | brown  |   6 |  9(5 rows)

Sem um ORDER BY cláusula, LIMIT fará seleções de uma maneira totalmente previsível. Os resultados retornados podem ser efetuados pela ordem das entradas na tabela ou por índices. Isso nem sempre é uma coisa ruim.

Se precisarmos de um registro para um único dog dentro da tabela, poderíamos construir uma consulta como esta. Lembre-se de que, embora o resultado possa ser difícil de prever, essa não é uma seleção aleatória e não deve ser usada como tal:
SELECT * FROM pet WHERE type = 'dog' LIMIT 1;
 
 type | name | color | age | id------+------+-------+-----+---- dog  | Spot | brown |   3 |  1(1 row)

Podemos usar o OFFSET cláusula para paginar pelos resultados. Incluímos um ORDER BY cláusula para definir uma ordem específica para os resultados.

Para a primeira consulta, limitamos os resultados sem especificar um OFFSET para obter as 3 primeiras entradas mais jovens:
SELECT * FROM pet ORDER BY age LIMIT 3;
 
 type | name  | color | age | id------+-------+-------+-----+---- dog  | Sally | brown |   1 |  3 dog  | Spot  | brown |   3 |  1 cat  | Felix | white |   4 |  5(3 rows)

Para obter os próximos 3 mais novos, podemos adicionar o número definido em LIMIT para o OFFSET para pular os resultados que já recuperamos:
SELECT * FROM pet ORDER BY age LIMIT 3 OFFSET 3;
 
  type  |  name   | color | age | id --------+---------+-------+-----+---- rabbit | Buttons | grey  |   4 |  7 rabbit | Briany  | brown |   6 |  9 dog    | Rover   | black |   7 |  2(3 rows)

Se adicionarmos o LIMIT para o OFFSET novamente, obteremos os próximos 3 resultados:
SELECT * FROM pet ORDER BY age LIMIT 3 OFFSET 6;
 
  type  |  name   | color  | age | id--------+---------+--------+-----+---- cat    | Simon   | orange |   8 |  6 rabbit | Bunny   | brown  |   8 |  8 cat    | Sabrina | black  |   8 |  4(3 rows)

Isso nos permite recuperar linhas de dados de uma consulta em partes gerenciáveis.



Conclusão


Há muitas maneiras de filtrar e restringir os resultados obtidos das consultas. Cláusulas como WHERE e HAVING avalie linhas ou grupos de linhas em potencial para ver se eles atendem a determinados critérios. O GROUP BY A cláusula ajuda a resumir dados agrupando registros que têm um ou mais valores de coluna em comum. O LIMIT cláusula oferece aos usuários a capacidade de definir um máximo no número de registros a serem recuperados.

Aprender como essas cláusulas podem ser aplicadas, individualmente ou em combinação, permitirá que você extraia dados específicos de grandes conjuntos de dados. Modificadores e filtros de consulta são essenciais para transformar os dados que residem no PostgreSQL em respostas úteis.