¿Debo usar! = O <> para no igual en T-SQL?

801

He visto SQLque usa ambos !=y <>para no igual . ¿Cuál es la sintaxis preferida y por qué?

Me gusta !=, porque <>me recuerda Visual Basic.

sql  sql-server  tsql 
— Bob el conserje
fuente
55
— Dinah
Portabilidad del código. Si ANSI SQL cumple fácilmente sus requisitos, entonces es mejor usarlo. Puede usar el mismo código en todas las bases de datos. P.ej. Un autor de libros SQL que quiere ilustrar SQL básico usando código de muestra.
— Steam
1
Me gustaría agregar un ejemplo en el que tener solo código ANSI SQL puede ser un problema: SQL estándar admite las opciones NULLS FIRST y NULLS LAST para controlar cómo se ordenan los NULL, pero T-SQL no admite esta opción.
— Steam
No hay necesidad de reabrir. La pregunta marcada es un duplicado, simplemente extendido por todo una más opción, NOT (A = B).
— TLama
@Steam, debe especificar a qué versión de año de ansi sql se refiere exactamente. Algunas de estas versiones incluso requieren que especifique la compatibilidad de nivel o las partes exactas del estándar. ¿Cuál de ellos presentó NULLS FIRST y NULLS LAST?
— Gherman

Respuestas:

539

Técnicamente funcionan igual si está utilizando SQL Server AKA T-SQL. Si lo está utilizando en procedimientos almacenados, no hay razón de rendimiento para usar uno sobre el otro. Luego se reduce a la preferencia personal. Prefiero usar <> ya que cumple con ANSI.

Puede encontrar enlaces a los diversos estándares ANSI en ...

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

— DBAndrew
fuente
41
Siempre he preferido usarlo !=debido a su existencia en todos los lenguajes influenciados por C que he usado, y porque la documentación de Python dice: "Las formas <>y !=son equivalentes; por coherencia con C, !=es preferible; donde !=se menciona a continuación <>también se acepta. La <>ortografía se considera obsoleta ". ¡Pero SQL no es Python!
— Iain Samuel McLean Élder
24
Me gusta usar <> porque me recuerda a XML. ¡Pero SQL no es XML!
— Rob Grant
32
Si; Microsoft recomienda utilizar <>más !=específicamente para el cumplimiento de ANSI, por ejemplo, en el kit de capacitación de Microsoft Press para el examen 70-461, "Consultar Microsoft SQL Server", dicen "Como ejemplo de cuándo elegir el formulario estándar, T-SQL admite dos" no igual a "operadores: <> y! =. El primero es estándar y el segundo no. Este caso debería ser un nobrainer: ¡elija el estándar!"
— Matt Gibson
10
Me gusta <> porque es más fácil de escribir.
— user2023861
731

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

Bases de datos que admiten ambos !=y <>:

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

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

  • IBM DB2 UDB 9.5: <>
  • Microsoft Access 2010: <>
— Bill Karwin
fuente
La consulta Django ORM se asigna a en NOT (a = b)lugar de (a <> b)o (a != b). ¿Es lo mismo internamente?
— usuario
77
@buffer, son lógicamente iguales, es decir, coincidirían o excluirían el mismo conjunto de filas. Pero si una marca RDBMS particular lo optimiza de la misma manera depende de la implementación. Dicho esto, me sorprendería si hubiera diferencias entre las marcas de bases de datos.
— Bill Karwin
nota al margen: LINQ en C # que tienes que usar! =
— Tom Stickel
! = es compatible con IBM DB2 LUW 10.5+
— Cristi S.
10
@ TomStickel LINQ en C # no es SQL.
— Craig
109

'<>'es del estándar SQL-92 y '!='es un operador propietario de T-SQL. 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, puede que tenga que hacer una búsqueda y reemplazar en su SQL.

— Adam Lassek
fuente
He visto que mysql sql también lo usa
— Bob The Janitor
3
¿Podemos seguir llamando a una extensión tan extendida del lenguaje estándar una propiedad exclusiva ? En este punto, parece que el estándar debería actualizarse para requerir, o al menos permitir ambas sintaxis.
— Johan Boulé
3
@JohanBoule bueno, hay un estándar escrito para SQL y que yo sepa !=no es parte de él. Aunque para todos los fines prácticos es un estándar de facto, no debemos confundir cuáles son y cuáles no son características estándar.
— Adam Lassek
24

Ambos son válidos e iguales con respecto a SQL Server ,

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

— madcolor
fuente
Eso es específico de SQL Server. Es cierto que pregunta sobre SQL Server, pero ¿puede encontrar una referencia de especificación ANSI para ver si está garantizado que sea portátil para aquellos de nosotros que nos gusta saber ese tipo de cosas?
— Joel Coehoorn el
66
@ Joel Coehoorn, si portas tu código T-SQL "<>" y "! =" Será la menor de tus preocupaciones.
— KM.
1
La transferencia no es el problema: es cuando, como desarrollador, se requiere que vaya y venga entre entornos. La consistencia es buena.
— Mark Ransom
20

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

— Kyle
fuente
15

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

Solo tuve que tomar algunas consultas SQL largas y colocarlas con amor en un archivo XML por un montón de estúpidas razones por las que no entraré.

Basta con decir que XML no funciona <>y tuve que cambiarlos !=y comprobarlo antes de que me desarmara.

— Albert gordo
fuente
66
¿por qué no solo CDATA? ¿Qué sucede cuando su consulta contiene XML?
— Janus Troelsen
12

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

— Steve
fuente
10

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

— Karl
fuente
7

Una alternativa sería usar el operador NULLIF que no sea <>o !=que devuelva NULL si los dos argumentos son NULLIF iguales en Microsoft Docs . Entonces, creo que la cláusula WHERE se puede modificar <>y de la !=siguiente manera:

NULLIF(arg1, arg2) IS NOT NULL

Como encontré eso, usar <>y !=no funciona para la fecha en algunos casos. Por lo tanto, usar la expresión anterior hace lo necesario.

— jitendrapurohit
fuente
66
No estoy seguro de si esta función funcionaría tan bien <>con respecto al uso del índice en todos los casos de esquina. Además, la legibilidad es ciertamente mucho peor ...
— Lukas Eder
Como mencioné en la respuesta, esto funcionó para mí en los campos de fecha allá en 2014. No estoy seguro de cuál era la cláusula / condición que restringía otras respuestas, pero mirando algunos de los votos positivos, esto parece estar ayudando a otros también.
— jitendrapurohit
1

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

— Andrea Antonangeli
fuente
-6

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 tardó unos 16 segundos en promedio en ejecutarse. Los cambié a <>y la consulta ahora tarda unos 4 segundos en promedio para ejecutarse. Esa es una gran mejora!

— Hamlet Javier
fuente
20
Si ejecuta dos consultas similares una tras otra en SQL Server, es probable que haya almacenado datos en la memoria caché y optimizado para consultas similares. Si lo hiciste en el orden inverso, ¡podrías encontrar el resultado opuesto!
— codemonkey
2
Esto también está mal, no tendrían dos operadores que funcionaran exactamente igual y uno era más lento "solo porque". Hay muchos factores que contribuyen a por qué la misma consulta producirá diferentes tiempos de ejecución.
— Elliot Chance
-11

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 al incluir sus índices en 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 atajarlo y hacer que funcionen de la misma manera, por lo que no hay ningún beneficio de ninguna manera. PostgreSQL y SQL Server no atacan esto; se lee como aparece arriba.

— Kevin Kinchen
fuente
3
¿Tiene alguna referencia de apoyo para su declaración? Ambos operadores parecen ser exactamente iguales en PostgreSQL , Oracle y MySQL .
— GhostGambler
8
Esto es completamente incorrecto, puede parecerle "mayor y menor que el valor almacenado" cuando combina esos caracteres en su mente, pero para el lexer es solo otra forma de representar el token.
— Elliot Chance
Falta de recursos relacionados!
— mostafa8026
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.