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

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

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

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

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: <>

'<>'é 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.

O ANSI SQL Standard define <>como o operador "não é igual a",

http://www.contrib.andrew.cmu.edu/~shadow/sql/sql1992.txt ( 5.2 <token> and <separator>)

Não há !=operador de acordo com o padrão ANSI / SQL 92.

<> é o SQL válido de acordo com o padrão SQL-92.

http://msdn.microsoft.com/en-us/library/aa276846(SQL.80).aspx

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

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 é <>.

!=, 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.

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 <>.

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).

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.

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.

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!

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.