¡Debería usarlo!= o < > para no igual en T-SQL?

La mayoría de las bases de datos soportan != (lenguajes de programación populares) y <> (ANSI).

Bases de datos que soportan != y <>:

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

Bases de datos que soportan el operador estándar ANSI, exclusivamente :

• IBM DB2 UDB 9.5: <>
• Microsoft Access 2010: <>

'<>' es del estándar SQL-92 y '!=' es un operador T-SQL propietario . También está disponible en otras bases de datos, pero como no es estándar, debe tomarlo caso por caso.

En la mayoría de los casos, sabrá a qué base de datos se está conectando, por lo que esto no es realmente un problema. En el peor de los casos, es posible que tenga que hacer una búsqueda y reemplazar en su SQL.

El estándar ANSI SQL define <> como el operador" no igual a",

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

No existe un operador != según el estándar ANSI/SQL 92.

<> es el SQL válido según el estándar SQL-92.

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

Ambos son válidos y lo mismo con respecto a SQL Server ,

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

Parece que los propios Microsoft prefieren <> a != como se evidencia en sus restricciones de tabla. Personalmente prefiero usar != porque claramente lo leo como "no igual", pero si ingresa [field1 != field2] y lo guarda como una restricción, la próxima vez que lo consulte, se mostrará como [field1 <> field2]. Esto me dice que la forma correcta de hacerlo es <>.

!=, a pesar de no ser ANSI, está más en el verdadero espíritu de SQL como un lenguaje legible. Grita no igual. <> dice que es para mí (menor que, mayor que) lo que es simplemente raro. Sé que la intención es que sea menor o mayor que, por lo tanto, no igual, pero esa es una forma realmente complicada de decir algo realmente simple.

Solo he tenido que tomar algunas consultas SQL largas y colocarlas amorosamente en un archivo XML por un montón de estúpidas razones por las que no iré en.

Basta con decir XML no está abajo con <> en absoluto y tuve que cambiarlos a != y comprobar a mí mismo antes de que riggedy destrozado a mí mismo.

Puede usar lo que quiera en T-SQL. La documentación dice que ambos funcionan de la misma manera. Prefiero !=, porque dice "no igual" a mi mente (basada en C/C++/C#), pero los gurús de la base de datos parecen preferir <>.

Entiendo que la sintaxis de C != está en SQL Server debido a su herencia Unix (en los días de Sybase SQL Server, antes de Microsoft SQL Server 6.5).

Una alternativa sería usar el operador NULLIF distinto de <> o != que devuelve NULL si los dos argumentos son iguales NULLIF en Microsoft Docs. Así que creo que DONDE la cláusula se puede modificar para <> y != de la siguiente manera:

NULLIF(arg1, arg2) IS NOT NULL

Como descubrí, usar <> y != no funciona para date en algunos casos. Por lo tanto, el uso de la expresión anterior hace lo necesario.

Preferí usar != en lugar de <> porque a veces uso la sintaxis <s></s> para escribir comandos SQL. Usar != es más útil para evitar errores de sintaxis en este caso.

Ambos son aceptados en T-SQL. Sin embargo, parece que el uso <> funciona mucho más rápido que !=. Acabo de ejecutar una consulta compleja que estaba usando !=, y tomó alrededor de 16 segundos en promedio para ejecutarse. Los cambié a <> y la consulta ahora tarda unos 4 segundos en ejecutarse en promedio. Eso es una gran mejora!

Aunque funcionan de la misma manera, != significa exactamente "no igual a", mientras que <> significa mayor y menor que el valor almacenado.

Considere >= o <=, y esto tendrá sentido cuando factorice sus índices para consultas... <> se ejecutará más rápido en algunos casos (con el índice correcto), pero en otros casos (sin índice) se ejecutarán de la misma manera.

Esto también depende de cómo su sistema de bases de datos lee los valores != y <>. El proveedor de la base de datos puede simplemente atajo y hacer que funcionan de la misma manera, por lo que no hay ningún beneficio de cualquier manera. PostgreSQL y SQL Server no acortan esto; se lee como aparece arriba.