Devo usar! = Ou <> para não ser igual no T-SQL?

801

Vi SQLque usa ambos !=e <>para não ser igual . Qual é a sintaxe preferida e por quê?

Eu gosto !=, porque <>me lembra Visual Basic.

Bob The Janitor
fonte
5
Veja também: stackoverflow.com/questions/7884/…
Dinah
Portabilidade do código. Se seus requisitos são facilmente atendidos pelo ANSI SQL, é melhor usá-lo. Você pode usar o mesmo código em todos os bancos de dados. Por exemplo. Um autor de livro SQL que deseja ilustrar o SQL básico usando código de exemplo.
Steam
1
Gostaria de adicionar um exemplo em que apenas o código SQL ANSI pode ser um problema - o SQL padrão oferece suporte às opções NULLS FIRST e NULLS LAST para controlar como os NULLs são classificados, mas o T-SQL não suporta essa opção.
Steam
Não há necessidade de reabertura. A pergunta marcada é uma duplicata, apenas estendida por mais uma opção NOT (A = B),.
TLama
@Steam, você deve especificar a versão do ano do ansi sql exatamente a que você está se referindo. Algumas dessas versões exigem que você especifique a compatibilidade de nível ou as partes exatas do padrão. Qual deles apresentou NULLS FIRST e NULLS LAST?
Gherman

Respostas:

539

Tecnicamente, eles funcionam da mesma maneira se você estiver usando o SQL Server AKA T-SQL. Se você o estiver usando em procedimentos armazenados, não há razão de desempenho para usar um sobre o outro. Em seguida, tudo se resume à preferência pessoal. Eu prefiro usar <>, pois é compatível com ANSI.

Você pode encontrar links para os vários padrões ANSI em ...

http://en.wikipedia.org/wiki/SQL

DBAndrew
fonte
41
Eu sempre preferi usar !=por causa de sua existência em todas as linguagens influenciadas por C que usei, e porque a documentação do Python diz: "Os formulários <>e !=são equivalentes; por consistência com C, !=é preferido; o que !=é mencionado abaixo <>também é aceito. A <>ortografia é considerada obsoleta. " Mas SQL não é Python!
Iain Samuel McLean Elder
24
Eu gosto de usar <> porque me lembra XML. Mas SQL não é XML!
Rob Grant
32
Sim; Microsoft si recomendo usar <>mais !=especificamente para o cumprimento ANSI, por exemplo, no Microsoft Press kit de treinamento para 70-461 exame, "Consultando o Microsoft SQL Server", eles dizem "Como um exemplo de quando a escolha da forma padrão, T-SQL suporta dois“não igual a ”operadores: <> e! =. O primeiro é padrão e o segundo não.
Matt Gibson
10
Eu gosto de <> porque é mais fácil digitar.
user2023861
731

A maioria dos bancos de dados suporta !=(linguagens de programação populares) e <>(ANSI).

Bancos de dados que suportam ambos !=e <>:

  • MySQL 5.1: !=e<>
  • PostgreSQL 8.3: !=e<>
  • SQLite: !=e<>
  • Oracle 10g: !=e<>
  • Microsoft SQL Server 2000/2005/2008/2012/2016: !=e<>
  • IBM Informix Dynamic Server 10: !=e<>
  • InterBase / Firebird: !=e<>
  • Apache Derby 10.6: !=e<>
  • Sybase Adaptive Server Enterprise 11.0: !=e<>

Bancos de dados que suportam o operador padrão ANSI, exclusivamente :

  • IBM DB2 UDB 9.5: <>
  • Microsoft Access 2010: <>
Bill Karwin
fonte
A consulta do ORM do Django é mapeada para em NOT (a = b)vez de (a <> b)ou (a != b). É o mesmo internamente?
usuário
7
@buffer, eles são logicamente iguais, ou seja, corresponderiam ou excluiriam o mesmo conjunto de linhas. Mas se uma determinada marca de RDBMS otimiza da mesma forma depende da implementação. Dito isto, ficaria surpreso se houvesse alguma diferença entre as marcas do banco de dados.
Bill Karwin
nota lateral: LINQ em c # você tem que usar! =
Tom Stickel
! = é suportado pelo IBM DB2 LUW 10.5+
Cristi S.
10
@ TomStickel LINQ em C # não é SQL.
Craig
109

'<>'é do padrão SQL-92 e '!='é um operador T-SQL proprietário . Também está disponível em outros bancos de dados, mas como não é padrão, você deve tomá-lo caso a caso.

Na maioria dos casos, você saberá a qual banco de dados está se conectando, e isso não é realmente um problema. Na pior das hipóteses, talvez você precise fazer uma pesquisa e substituir no seu SQL.

Adam Lassek
fonte
Tenho ver mysql sql usá-lo também
Bob The Janitor
3
Podemos continuar chamando uma extensão tão difundida para o idioma padrão de uma linguagem proprietária ? Nesse ponto, parece que o padrão deve ser atualizado para exigir ou pelo menos permitir as duas sintaxes.
Johan Boulé 23/05
3
@JohanBoule bem, existe um padrão escrito para SQL e, pelo que sei, não faz !=parte dele. Mesmo que, para todos os efeitos práticos, seja um padrão padrão, não devemos confundir o que são e os que não são recursos padrão.
Adam Lassek
24

Eles são válidos e iguais em relação ao SQL Server ,

https://docs.microsoft.com/en-us/sql/t-sql/language-elements/not-equal-to-transact-sql-exclamation

madcolor
fonte
Isso é específico do SQL Server. É verdade que ele pergunta sobre o SQL Server, mas você pode encontrar uma referência de especificação ANSI para ver se ela é portátil para aqueles de nós que gostam de saber esse tipo de coisa?
Joel Coehoorn
6
@ Joel Coehoorn, se você portar muito o seu código T-SQL "<>" e "! =" Será a menor das suas preocupações!
KM.
1
Portar não é o problema - é quando, como desenvolvedor, você é obrigado a ir e voltar entre ambientes. Consistência é boa.
Mark Ransom
20

Parece que a Microsoft-se preferir <>a !=como evidenciado em suas restrições de tabela. Pessoalmente, prefiro usar !=porque li claramente que "não é igual", mas se você o inserir [field1 != field2]e salvar como construtor, na próxima vez em que for consultá-lo, ele aparecerá como [field1 <> field2]. Isso me diz que a maneira correta de fazer isso é <>.

Kyle
fonte
15

!=, apesar de não ser ANSI, está mais no verdadeiro espírito do SQL como uma linguagem legível. Grita não é igual. <>diz que é para mim (menor que, maior que) o que é estranho. Eu sei que a intenção é que seja menor ou maior do que não seja igual, mas essa é uma maneira realmente complicada de dizer algo realmente simples.

Eu apenas tive que fazer algumas consultas SQL longas e colocá-las com carinho em um arquivo XML por várias razões estúpidas nas quais não vou entrar.

Basta dizer que o XML não está de acordo com <>isso e eu tive que alterá-los !=e me verificar antes de me estragar.

Fat Albert
fonte
6
por que não apenas CDATA isso? o que acontece quando sua consulta contém XML?
Janus Troelsen
12

Você pode usar o que quiser no T-SQL. A documentação diz que ambos funcionam da mesma maneira. Eu prefiro !=, porque lê "não é igual" à minha mente (baseada em C / C ++ / C #), mas os gurus do banco de dados parecem preferir <>.

Steve
fonte
10

Entendo que a sintaxe C !=está no SQL Server devido a sua herança Unix (nos dias do Sybase SQL Server, antes do Microsoft SQL Server 6.5).

Karl
fonte
7

Uma alternativa seria usar o operador NULLIF que não seja <>ou !=que retorne NULL se os dois argumentos forem iguais a NULLIF no Microsoft Docs . Portanto, acredito que a cláusula WHERE pode ser modificada para <>e da !=seguinte forma:

NULLIF(arg1, arg2) IS NOT NULL

Como eu descobri, usar <>e !=não funciona para a data em alguns casos. Portanto, o uso da expressão acima faz o necessário.

jitendrapurohit
fonte
6
Não tenho certeza se essa função funcionaria tão bem quanto <>em relação ao uso do índice em todos os casos de canto. Além disso, a legibilidade é certamente muito pior ...
Lukas Eder
Como mencionei na resposta, isso funcionou para mim nos campos de datas lá em 2014. Não sei qual era a cláusula / condição que restringia outras respostas, mas olhando para algumas das votações positivas, isso também parece ajudar outras pessoas.
precisa saber é o seguinte
1

Eu preferi usar em !=vez de, <>porque às vezes eu uso a <s></s>sintaxe para escrever comandos SQL. O uso !=é mais útil para evitar erros de sintaxe nesse caso.

Andrea Antonangeli
fonte
-6

Ambos são aceitos no T-SQL. No entanto, parece que o uso <>funciona muito mais rápido que!= . Acabei de executar uma consulta complexa em uso !=e demorou cerca de 16 segundos em média para ser executada. Alterei-os para <>e a consulta agora leva em média 4 segundos para ser executada. Isso é uma grande melhoria!

Hamlet Javier
fonte
20
Se você executar duas consultas semelhantes uma após a outra no SQL Server, provavelmente terá dados em cache na memória e otimizados para consultas semelhantes. Se você fez isso na ordem inversa, poderá encontrar o resultado oposto!
Codigokey
2
Isso também está errado, eles não teriam dois operadores que funcionavam exatamente da mesma forma e um era mais lento "apenas porque". Existem muitos fatores que contribuem para o motivo pelo qual a mesma consulta produzirá tempos de execução diferentes.
Elliot Chance
-11

Embora funcionem da mesma maneira, !=significa exatamente "diferente de", enquanto<> significa maior que e menor que o valor armazenado.

Considere >=ou <=, e isso fará sentido ao incluir nos seus índices as consultas ...<> será executada mais rapidamente em alguns casos (com o índice correto), mas em outros casos (sem índice) eles serão executados da mesma forma.

Isso também depende de como o sistema de bancos de dados lê os valores !=e <>. O provedor do banco de dados pode apenas atalho e fazê-los funcionar da mesma maneira, para que não haja nenhum benefício. O PostgreSQL e o SQL Server não atalhos; é lido como aparece acima.

Kevin Kinchen
fonte
3
Você tem alguma referência de suporte para sua declaração? Ambos os operadores parecem exatamente iguais no PostgreSQL , Oracle e MySQL .
GhostGambler
8
Isso está completamente errado, pode parecer-lhe "maior que e menor que o valor armazenado" quando você combina esses caracteres em sua mente, mas para o lexer é apenas mais uma maneira de representar o token.
Elliot Chance
Falta de recursos relacionados!
mostafa8026