Início / dba / Perguntas / 155650
Accepted
ErikE
Asked: 2016-11-18 14:39:48 +0800 CST

Fonte autoritativa que <> e != são idênticas em desempenho no SQL Server

  • 772

Considere esta resposta no SO que tranquiliza o questionador sobre o <>operador que:

<>é ... o mesmo que !=.

Mas então um comentarista se intromete e diz:

É verdade que eles são, funcionalmente, os mesmos. No entanto, como o otimizador SQL os usa é muito diferente. =/!= são simplesmente avaliados como verdadeiro/falso, enquanto <> significa que o mecanismo precisa verificar se o valor é maior ou menor, o que significa mais sobrecarga de desempenho. Apenas algo a considerar ao escrever consultas que podem ser caras.

Estou confiante de que isso é falso, mas, para abordar os céticos em potencial, me pergunto se alguém pode fornecer uma fonte autorizada ou canônica para provar que esses operadores não são apenas funcionalmente iguais, mas idênticos em todos os aspectos.

sql-server performance

4 respostas

  1. Best Answer

    Durante a análise , o SQL Server chama sqllang!DecodeCompOppara determinar o tipo de operador de comparação presente:

    pilha de chamadas

    Isso ocorre bem antes de qualquer coisa no otimizador se envolver.

    De operadores de comparação (Transact-SQL)

    Operadores de comparação e significados

    Rastreando o código usando um depurador e símbolos públicos*, sqllang!DecodeCompOpretorna um valor no registrador eax** da seguinte forma:

    ╔════╦══════╗
║ Op ║ Code ║
╠════╬══════╣
║ <  ║    1 ║
║ =  ║    2 ║
║ <= ║    3 ║
║ !> ║    3 ║
║ >  ║    4 ║
║ <> ║    5 ║
║ != ║    5 ║
║ >= ║    6 ║
║ !< ║    6 ║
╚════╩══════╝

    !=e <>ambos retornam 5, então são indistinguíveis em todas as operações posteriores (incluindo compilação e otimização).

    Embora secundário ao ponto acima, também é possível (por exemplo, usando o sinalizador de rastreamento não documentado 8605) examinar a árvore lógica passada para o otimizador para confirmar que ambos mapeiam para !=( não é igual à comparação do operador escalar).<>ScaOp_Comp x_cmpNe

    Por exemplo:

    SELECT P.ProductID FROM Production.Product AS P
WHERE P.ProductID != 4
OPTION (QUERYTRACEON 3604, QUERYTRACEON 8605);

SELECT P.ProductID FROM Production.Product AS P
WHERE P.ProductID <> 4
OPTION (QUERYTRACEON 3604, QUERYTRACEON 8605);

    ambos produzem:

    LogOp_Project QCOL: [P].ProductID
    LogOp_Select
        LogOp_Get TBL: Production.Product(alias TBL: P)
        ScaOp_Comp x_cmpNe
            ScaOp_Identifier QCOL: [P].ProductID
            ScaOp_Const TI(int,ML=4) XVAR(int,Não possui,Valor=4)
    AncOp_PrjList

    notas de rodapé

    * Eu uso o WinDbg ; outros depuradores estão disponíveis. Os símbolos públicos estão disponíveis através do servidor de símbolos normal da Microsoft. Para obter mais informações, consulte Olhando mais profundamente no SQL Server usando Minidumps pela equipe de consultoria do cliente do SQL Server e Depuração do SQL Server com WinDbg – uma introdução de Klaus Aschenbrenner.

    ** O uso de EAX em derivados da Intel de 32 bits para valores de retorno de uma função é comum. Certamente o Win32 ABI faz dessa maneira, e tenho certeza que herda essa prática dos velhos tempos do MS-DOS, onde o AX era usado para o mesmo propósito - Michael Kjörling

    • 176

  2. Trabalho na Microsoft com suporte SQL e perguntei a Jack Li, engenheiro sênior de escalonamento e especialista no assunto de desempenho do SQL Server: "O SQL trata != de maneira diferente de <> ?" e ele disse: "Eles são os mesmos."

    • 65

  3. Acho que o seguinte prova que <>não faz 2 comparações.

    1. SQL Standard 92 define <>como operador diferente, ( http://www.contrib.andrew.cmu.edu/~shadow/sql/sql1992.txt ). Tecnicamente, !=é uma extensão do padrão (embora eu não consiga pensar em nenhum RDBMS que não o implemente).
    2. Se o SQLServer tratasse <>como 2 operadores, não um, faria o mesmo para o ><qual é de fato um erro de sintaxe.
    • 8

  4. Isso está incorreto, Books Online (BOL) diz que eles são funcionalmente iguais:

    != (Não é igual a) (Transact-SQL)

    E se você olhar para um plano de execução onde !=é usado, em Predicado, ele muda != para <>.

    • 2

relate perguntas