Qual é a diferença entre ter e onde?

Eu devo estar pesquisando da maneira errada ou estou tendo um momento estúpido no tempo.

Qual é a diferença entre HAVING e WHERE em uma SQL SELECT ?

EDIT: Eu marquei a resposta de Steven como a correta, pois continha o bit chave de informação no link:

Quando GROUP BY não é usado, o comportamento HAVING se comporta como uma cláusula WHERE

A situação em que eu vi o WHERE não teve GROUP BY e é onde minha confusão começou. Claro, até que você saiba disso, você não pode especificá-lo na questão.

Muito obrigado por todas as respostas que foram muito esclarecedoras.

    HAVING especifica uma condição de pesquisa para um grupo ou uma function agregada usada na instrução SELECT.

    Fonte

    TENDO: é usado para verificar as condições após a agregação.
    ONDE: é usado para verificar as condições antes que a agregação ocorra.

    Este código:

     select City, CNT=Count(1) From Address Where State = 'MA' Group By City 

    Dá-lhe uma tabela de todas as cidades em MA e o número de endereços em cada cidade.

    Este código:

     select City, CNT=Count(1) From Address Where State = 'MA' Group By City Having Count(1)>5 

    Dá-lhe uma tabela de cidades em MA com mais de 5 endereços e o número de endereços em cada cidade.

    Diferença entre a cláusula WHERE e HAVING:

    1. Cláusula WHERE pode ser usada com – Selecionar, Inserir e Atualizar instruções, onde a cláusula HAVING só pode ser usada com a instrução Select.

    2. WHERE filtra linhas antes da agregação (GROUPING), onde, como HAVING filtra grupos, depois que as agregações são executadas.

    3. As funções agregadas não podem ser usadas na cláusula WHERE , a menos que estejam em uma subconsulta contida em uma cláusula HAVING , ao passo que funções agregadas podem ser usadas na cláusula Having.

    Grupos de Filtragem:

    A cláusula WHERE é usada para filtrar linhas antes da agregação, onde a cláusula HAVING é usada para filtrar grupos após agregações

     Select City, SUM(Salary) as TotalSalary from tblEmployee Where Gender = 'Male' group by City Having City = 'London' 

    No SQL Server, temos muitas funções agregadas. Exemplos

    1. Count()
    2. Sum()
    3. avg()
    4. Min()
    5. Max()

    Diferença número um para mim: se o HAVING fosse removido da linguagem SQL, a vida continuaria mais ou menos como antes. Certamente, as consultas minoritárias precisariam ser reescritas usando uma tabela derivada, CTE etc., mas elas seriam mais fáceis de entender e manter como resultado. Talvez o código otimizador dos fornecedores precisaria ser reescrito para compensar isso, mais uma vez uma oportunidade de melhoria no setor.

    Agora, considere por um momento remover WHERE da linguagem. Desta vez, a maioria das consultas existentes precisaria ser reescrita sem uma construção alternativa óbvia. Os codificadores teriam que ser criativos, por exemplo, inner join para uma tabela conhecida por conter exatamente uma linha (por exemplo, DUAL no Oracle) usando a cláusula ON para simular a cláusula WHERE anterior. Tais construções seriam planejadas; seria óbvio que algo estava faltando na língua e a situação seria pior como resultado.

    TL; DR poderíamos perder tendo amanhã e as coisas não seriam piores, possivelmente melhores, mas o mesmo não se pode dizer de WHERE .


    Das respostas aqui, parece que muitas pessoas não percebem que uma cláusula HAVING pode ser usada sem uma cláusula GROUP BY . Nesse caso, a cláusula HAVING é aplicada a toda a expressão de tabela e requer que apenas constantes apareçam na cláusula SELECT . Normalmente, a cláusula HAVING envolverá agregados.

    Isso é mais útil do que parece. Por exemplo, considere esta consulta para testar se a coluna de name é exclusiva para todos os valores em T :

     SELECT 1 AS result FROM T HAVING COUNT( DISTINCT name ) = COUNT( name ); 

    Existem apenas dois resultados possíveis: se a cláusula HAVING for verdadeira, o resultado será uma única linha contendo o valor 1 ; caso contrário, o resultado será o conjunto vazio.

    A cláusula HAVING foi incluída no SQL porque a palavra-chave WHERE não pôde ser usada com funções agregadas.

    Confira este link w3schools para mais informações

    Sintaxe:

     SELECT column_name, aggregate_function(column_name) FROM table_name WHERE column_name operator value GROUP BY column_name HAVING aggregate_function(column_name) operator value 

    Uma consulta como esta:

     SELECT column_name, COUNT( column_name ) AS column_name_tally FROM table_name WHERE column_name < 3 GROUP BY column_name HAVING COUNT( column_name ) >= 3; 

    … pode ser reescrito usando uma tabela derivada (e omitindo o HAVING ) assim:

     SELECT column_name, column_name_tally FROM ( SELECT column_name, COUNT(column_name) AS column_name_tally FROM table_name WHERE column_name < 3 GROUP BY column_name ) pointless_range_variable_required_here WHERE column_name_tally >= 3; 

    A diferença entre os dois está no relacionamento com a cláusula GROUP BY:

    • WHERE vem antes de GROUP BY; O SQL avalia a cláusula WHERE antes de agrupar registros.

    • TENDO depois do GROUP BY; O SQL avalia o HAVING depois de agrupar registros.

    selecione o diagrama de declaração

    Referências

    • Sintaxe da instrução SQLite SELECT / diagrama de ferrovia

    • Diagrama Sintaxe / Ferrovia da instrução SELECT do Informix

    HAVING é usado quando você está usando um agregado como GROUP BY .

     SELECT edc_country, COUNT(*) FROM Ed_Centers GROUP BY edc_country HAVING COUNT(*) > 1 ORDER BY edc_country; 

    WHERE é aplicado como uma limitação no conjunto retornado pelo SQL; ele usa as configurações e os índices internos do SQL e, portanto, é a maneira mais rápida de filtrar os conjuntos de resultados. Sempre use onde, sempre que possível.

    Ter é necessário para alguns filtros agregados. Ele filtra a consulta AFTER sql recuperou, montou e classificou os resultados. Portanto, é muito mais lento do que o WHERE e deve ser evitado, exceto naquelas situações que o exijam.

    O SQL Server permitirá que você use o HAVING mesmo quando o WHERE for muito mais rápido. Não faça isso.

    Cláusula WHERE não funciona para funções agregadas
    significa: você não deve usar como este bônus: nome da tabela

     SELECT name FROM bonus GROUP BY name WHERE sum(salary) > 200 

    AQUI Em vez de usar a cláusula WHERE você tem que usar o HAVING ..

    sem usar a cláusula GROUP BY, a cláusula HAVING apenas funciona como cláusula WHERE

     SELECT name FROM bonus GROUP BY name HAVING sum(salary) > 200 

    Quando GROUP BY não é usado, as cláusulas WHERE e HAVING são essencialmente equivalentes.

    No entanto, quando GROUP BY é usado:

    • A cláusula WHERE é usada para filtrar registros de um resultado. A filtragem ocorre antes de qualquer agrupamento ser feito.
    • A cláusula HAVING é usada para filtrar valores de um grupo (isto é, para verificar as condições após a agregação em grupos ter sido executada).

    Recurso daqui

    Diferença b / w WHERE e cláusula HAVING :

    A principal diferença entre a cláusula WHERE e HAVING é, WHERE é usada para operações de linha e HAVING é usado para operações de coluna.

    Por que precisamos da cláusula HAVING ?

    Como sabemos, as funções agregadas só podem ser executadas em colunas, portanto, não podemos usar funções agregadas na cláusula WHERE . Portanto, usamos funções agregadas na cláusula HAVING .

    Eu tive um problema e descobri outra diferença entre WHERE e HAVING . Não age da mesma maneira em colunas indexadas.

    WHERE my_indexed_row = 123 mostrará linhas e executará automaticamente um “ORDER ASC” em outras linhas indexadas.

    HAVING my_indexed_row = 123 mostra tudo, desde a mais antiga linha “inserida” até a mais nova, sem ordem.

    Em uma consulta Agregada, (Qualquer consulta em que uma function agregada é usada) Os predicados em uma cláusula where são avaliados antes que o conjunto de resultados intermediários agregado seja gerado,

    Os predicados em uma cláusula Having são aplicados ao conjunto de resultados agregados APÓS ter sido gerado. É por isso que as condições de predicado nos valores agregados devem ser colocadas em Cláusula Tendo, não na cláusula Where e por que você pode usar aliases definidos na cláusula Select em uma Cláusula Having, mas não em uma Cláusula Where.

    A cláusula WHERE é usada para comparar valores na tabela base, enquanto a cláusula HAVING pode ser usada para filtrar os resultados de funções agregadas no conjunto de resultados da consulta. Clique aqui !

    Uma maneira de pensar nisso é que a cláusula having é um filtro adicional para a cláusula where.

    Uma cláusula WHERE é usada para filtrar registros de um resultado. O filtro ocorre antes de qualquer agrupamento ser feito. Uma cláusula HAVING é usada para filtrar valores de um grupo

    A cláusula WHERE é avaliada antes de as linhas serem agrupadas e, portanto, é avaliada por linha.

    A cláusula HAVING é avaliada após as linhas serem agrupadas e, portanto, é avaliada por grupo.

    Eu uso HAVING para restringir uma consulta com base nos resultados de uma function agregada. EG select * no grupo blahblahblah por SOMETHING tendo count (SOMETHING)> 0

    Daqui.

    o padrão SQL requer que HAVING tenha que referenciar somente colunas na cláusula GROUP BY ou colunas usadas em funções agregadas

    ao contrário da cláusula WHERE que é aplicada às linhas do database

    Enquanto trabalhava em um projeto, essa também era a minha pergunta. Como dito acima, o HAVING verifica a condição no resultado da consulta já encontrado. Mas WHERE é para verificar a condição enquanto a consulta é executada.

    Deixe-me dar um exemplo para ilustrar isso. Suponha que você tenha uma tabela de database como essa.

    utilizável {int userid, date datefield, int dailyincome}

    Suponha que as seguintes linhas estejam na tabela:

    1, 2011-05-20, 100

    1, 2011-05-21, 50

    1, 2011-05-30, 10

    2, 2011-05-30, 10

    2, 2011-05-20, 20

    Agora, queremos obter os userid s e sum(dailyincome) cuja sum(dailyincome)>100

    Se nós escrevermos:

    SELECT userid, sum (dailyincome) FROM usável WHERE sum (dailyincome)> 100 ID do usuário GROUP BY

    Isso será um erro. A consulta correta seria:

    SELECT userid, sum (dailyincome) FROM usável GROUP BY userid HAVING sum (diário)> 100

    Pode ser apenas que o assunto de “onde” é uma linha, enquanto o assunto de “ter” é um grupo. Estou certo?