Como contar valor postgresql e comparar

A função COUNT() pode ser usada para encontrar dados redundantes ou determinar a quantidade de vezes que uma informação se encontra inserida em uma tabela. Pode vir acompanhada da cláusula GROUP BY para agrupar as ocorrências, na lista — o que torna o relatório mais fácil de compreender.

Índice Show

A função COUNT() do MySQL
Como usar COUNT() com a cláusula GROUP BY
Exemplo de utilização:
Artigos Relacionados:

Se esta situação for um problema para você, leia o artigo Como eliminar registros duplicados no MySQL, para entender como resolvê-la.

Neste texto, vou usar exemplos com a seguinte tabela (vista parcialmente):

SELECT * FROM clientesEstaduais LIMIT 10; +----+------------------+---------------+--------------+---------------+ | id | NomeCliente | RegiaoCliente | DataCadastro | CreditCliente | +----+------------------+---------------+--------------+---------------+ | 1 | Kiara Meadows | SP | 2010-11-30 | 2614 | | 2 | Iris Moreno | SP | 2013-03-05 | 13818 | | 3 | Camilla Klein | GO | 2011-04-08 | 4954 | | 4 | Stephanie Thomas | BA | 2014-10-06 | 1678 | | 5 | Emerald Alston | PE | 2013-12-02 | 12574 | | 6 | Nevada Phelps | PR | 2014-07-26 | 5080 | | 7 | Nita Solomon | MG | 2013-04-15 | 2267 | | 8 | Suki Ayers | MG | 2014-10-08 | 12884 | | 9 | Camille Ray | RS | 2013-07-11 | 13807 | | 10 | Chloe Gibbs | CE | 2012-11-06 | 8165 | +----+------------------+---------------+--------------+---------------+ 10 rows in set (0.00 sec)

A tabela clientesEstaduais, pode ser encontrada aqui.

A função COUNT() do MySQL

A sintaxe da função é simples: COUNT(expressão).
Veja como contar a quantidade de registros da tabela clientesEstaduais:

SELECT COUNT(*) AS "Qtd. de registros" FROM clientesEstaduais; +-------------------+ | Qtd. de registros | +-------------------+ | 100 | +-------------------+

Veja outras perguntas que podem ser respondidas com o uso da função COUNT() aliada à cláusula WHERE
Quantos clientes são do estado do Paraná (PR)?

SELECT COUNT(*) AS "Clientes do PR" FROM clientesEstaduais WHERE RegiaoCliente = 'PR'; +----------------+ | Clientes do PR | +----------------+ | 6 | +----------------+

Quantos clientes foram cadastros em Agosto (em qualquer dia/ano)?

SELECT COUNT(*) AS "Clientes de Agosto" FROM clientesEstaduais WHERE MONTH(DataCadastro)='08'; +--------------------+ | Clientes de Agosto | +--------------------+ | 12 | +--------------------+

Quantos clientes têm mais de 15 mil em créditos?

SELECT COUNT(*) AS "> 15.000" FROM clientesEstaduais WHERE CreditCliente > 15000; +----------+ | > 15.000 | +----------+ | 19 | +----------+

A função COUNT(), tem 2 formas.
A que temos usado, até agora, serve para contar as linhas da tabela: COUNT(*).
A outra forma usa uma expressão, como argumento e é usada para contar os valores não NULL ou non-NULL. Em outras palavras, registros que contenham o campo NULL, não entram na conta, quando a expressão é dada como argumento.

Veja um exemplo:

SELECT COUNT(*) AS "Núm. de clientes", -> COUNT(DataCadastro) AS "Clientes cadastrados" -> FROM clientesEstaduais;

Uma vez que 2 clientes têm data de cadastro vazia (DataCadastro = NULL), a segunda coluna só irá contar 98:

+-------------------+----------------------+ | Núm. de clientes | Clientes cadastrados | +-------------------+----------------------+ | 100 | 98 | +-------------------+----------------------+

Como usar COUNT() com a cláusula GROUP BY

Além de ver os valores, você pode listar os registros, para ter um relatório mais rico.
No exemplo, abaixo, veja como obter a relação de estados presentes no cadastro de clientes, a quantidade de clientes por estado e em ordem descendente:

SELECT RegiaoCliente AS "Estados", -> COUNT(*) AS "Núm. de clientes" -> FROM clientesEstaduais -> GROUP BY RegiaoCliente -> ORDER BY COUNT(*) DESC; +---------+-------------------+ | Estados | Núm. de clientes | +---------+-------------------+ | SP | 30 | | MG | 18 | | BA | 10 | | RJ | 9 | | PR | 6 | | RS | 6 | | PE | 5 | | CE | 5 | | GO | 5 | | MA | 3 | | PA | 2 | | PB | 1 | +---------+-------------------+

No mês de Agosto, em quais datas houve maior número de cadastros?

SELECT DataCadastro, -> COUNT(*) FROM clientesEstaduais -> WHERE MONTH(DataCadastro)='08' -> GROUP BY DataCadastro -> ORDER BY COUNT(*) DESC; +--------------+----------+ | DataCadastro | COUNT(*) | +--------------+----------+ | 2016-08-21 | 2 | | 2016-08-15 | 2 | | 2016-08-11 | 2 | | 2016-08-19 | 1 | | 2016-08-16 | 1 | | 2016-08-20 | 1 | | 2016-08-13 | 1 | | 2016-08-17 | 1 | | 2016-08-09 | 1 | +--------------+----------+

Samuel,

Apenas exemplificando, conforme o Wesley postou, vc pode usar o not exists ou o EXCEPT, caso seu sql server for 2005 ou 2008.

--create table #EscalaOperacao (Id_EscalaOperacao int) --create table #Corrigidos (IdsCorrigidos int) -- --insert into #EscalaOperacao (Id_EscalaOperacao) values (901924) --insert into #EscalaOperacao (Id_EscalaOperacao) values (902062) --insert into #EscalaOperacao (Id_EscalaOperacao) values (903227) --insert into #EscalaOperacao (Id_EscalaOperacao) values (924159) --insert into #EscalaOperacao (Id_EscalaOperacao) values (943551) --insert into #EscalaOperacao (Id_EscalaOperacao) values (943644) -- --insert into #Corrigidos (IdsCorrigidos) values (901924) --insert into #Corrigidos (IdsCorrigidos) values (902062) --insert into #Corrigidos (IdsCorrigidos) values (924159) --insert into #Corrigidos (IdsCorrigidos) values (943644) --insert into #Corrigidos (IdsCorrigidos) values (944505) --insert into #Corrigidos (IdsCorrigidos) values (949338) select * from #EscalaOperacao a where not exists (select null from #Corrigidos b where a.Id_EscalaOperacao = b.IdsCorrigidos) select Id_EscalaOperacao from #EscalaOperacao except select IdsCorrigidos from #Corrigidos

att.
Rafael

Quando vamos usar count no banco de dados nos deparamos com várias opções do SQL, conheça as diferenças entre as várias possibilidades de contar linhas de tabela com count em um banco de dados.

Como um exemplo, quantos produtos tem minha empresa mesmo?

select count(nome) from Produtos; > 198

Mas...

select count(id) from Produtos; > 200

Como assim? SQL pirou? De novo?

select id, nome from Produtos where nome is null; > 190, null > 196, null

O select count verifica o número de linhas não nulas dentro do count que você quer fazer! Se tinha nome nulo, não contou! Resultado? Zoou.

Muito cuidado com seus counts. Então o que devo contar? Se você quer contar valores não nulos, use o count(campo), como fizemos:

select count(nome) from Produtos; > 198

Mas se quer contar todos, count estrela nele pra não correr risco, ele vai contar o número de registros retornados, independentemente de valores nulos:

select count(\*) from Produtos; > 200

E o 1? Pra que o count(1)?

select count(1) from Produtos; > 200

O count(1) seria uma alternativa ao count(algum_campo) pois você teria certeza que nunca seria nulo, e que não precisaria ler o campo... acontece que fica bizarro select count(1), e você quer ter código bizarro ou código legível?

Como disse, eu prefiro contar estrelas... e você, conta estrelas conta um ou conta id?

Fica agora o desafio: qual o resultado da SQL a seguir?

select count(nome) from Produtos where nome is null; > ??????

Gostou dessas práticas e dicas de SQL? Então confira também os cursos que temos na Alura para a SQL e banco de dados! Outro assunto legal para estudar é sobre o que são como usar trigger em SQL. Até o próximo artigo ;)

Possuo um campo da tabela que recebe o valor de um tag com o somatório geral de determinada variável do sistema; entretanto, preciso exibir a diferença (subtração) entre os valores dos registros desta tabela, e não seu valor acumulado. Como calcular a diferença entre os registros?

NOTA: A solução proposta neste artigo, que utiliza a função analítica LAG (Transact-SQL), aplica-se ao SQL Server 2012 e versões superiores; para as demais versões e outros bancos de dados, há outra solução alternativa, publicada ao final do artigo.

Solução:

Neste caso, podemos utilizar a função analítica LAG (Transact-SQL), que acessa os dados de uma linha anterior no mesmo conjunto de resultados. A função foi inserida no SQL Server 2012; é possível utilizá-la em uma instrução SELECT, que compara valores na linha atual com valores em uma linha anterior.

Sintaxe

LAG (scalar_expression [,offset] [,default])
OVER ( [ partition_by_clause ] order_by_clause )

Argumentos

scalar_expression
Este é valor a ser retornado com base no deslocamento especificado. É uma expressão de qualquer tipo, que retorna um único valor (escalar). scalar_expression não pode ser uma função analítica.

offset
Este é o número de linhas atrás da linha atual de onde se obtém um valor. Caso não seja especificado, o padrão será 1. offset pode ser uma coluna, subconsulta ou outra expressão avaliada para um inteiro positivo, ou então pode ser convertida implicitamente em bigint. Entretanto, offset não pode ser um valor negativo nem uma função analítica.

default
Este é valor a ser retornado quando offset estiver além do escopo da partição. Se um valor padrão não for especificado, o valor NULL será retornado. default pode ser uma coluna, subconsulta ou outra expressão, mas não pode ser uma função analítica. Portanto, default deve ter o tipo compatível com scalar_expression.

OVER ( [ partition_by_clause ] order_by_clause )
partition_by_clause divide o conjunto de resultados produzido pela cláusula FROM em partições às quais a função é aplicada. Caso não seja especificado, então a função tratará todas as linhas do conjunto de resultados da consulta como um único grupo.

order_by_clause determina a ordem dos dados antes que a função seja aplicada. Se partition_by_clause for especificado, ela então determinará a ordem dos dados na partição. order_by_clause é obrigatória. Para obter mais informações, consulte Cláusula OVER (Transact-SQL).

Exemplo de utilização:

1. Primeiramente: criando a tabela:

CREATE TABLE Hist_1 ( E3TimeStamp datetime not null, SE_10F03 int not null, P1F01 int not null, P2F01 int not null )

2. Logo após: inserindo valores:

INSERT INTO Hist_1 (E3TimeStamp, SE_10F03, P1F01, P2F01) VALUES ('17-01-2020 15:34:00', 425, 182, 345), ('17-01-2020 15:38:00', 445, 189, 356), ('17-01-2020 15:42:00', 465, 199, 360), ('17-01-2020 15:48:00', 485, 203, 394), ('17-01-2020 15:52:00', 502, 206, 454), ('17-01-2020 15:56:00', 506, 209, 480)

3. Retornando os dados inseridos anteriormente:

SELECT * FROM Hist_1

4. Utilizando a função LAG para então obter a diferença entre os registros:

SELECT Hist_1.E3TimeStamp, ISNULL((Hist_1.SE_10F03 - LAG(Hist_1.SE_10F03,1) OVER (ORDER BY Hist_1.E3TimeStamp ASC)) ,0) as SE_10F03, ISNULL((Hist_1.P1F01 - LAG(Hist_1.P1F01,1) OVER (ORDER BY Hist_1.E3TimeStamp ASC)) ,0) as P1F01, ISNULL((Hist_1.P2F01 - LAG(Hist_1.P2F01,1) OVER (ORDER BY Hist_1.E3TimeStamp ASC)) ,0) as P2F01 FROM Hist_1 ORDER BY Hist_1.E3TimeStamp ASC

Outra alternativa seria utilizar a seguinte sintaxe SQL:

SELECT E3TimeStamp ,[SE_10F03] ,[SE_10F03] - ( SELECT TOP 1 [SE_10F03] FROM [Hist_1] b WHERE a.E3TimeStamp > b.E3TimeStamp ORDER BY b.E3TimeStamp DESC) as Diff FROM [Hist_1] a