tipos - ¿Debo usar!=O<> para no ser igual en T-SQL?
tipos de datos en sql server (14)
Ambos son aceptados en T-SQL. Sin embargo, parece que usar <> funciona mucho más rápido que != . Acabo de ejecutar una consulta compleja que estaba usando != , Y tardó aproximadamente 16 segundos en ejecutarse. Los cambié a <> y ahora la consulta tarda aproximadamente 4 segundos en ejecutarse. ¡Eso es una gran mejora!
He visto SQL que usa ambos != y <> para no ser igual . ¿Cuál es la sintaxis preferida y por qué?
Me gusta != , Porque <> me recuerda a Visual Basic .
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
Aunque funcionan de la misma manera != Significa exactamente "no igual a", mientras que <> significa mayor que y menor que el valor almacenado.
Considere >= o <= , y esto tendrá sentido cuando tenga en cuenta sus índices a las consultas ... <> se ejecutará más rápido en algunos casos (con el índice correcto), pero en otros casos (índice libre) solo se ejecutarán lo mismo.
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 hacer un atajo y hacer que funcionen de la misma manera, por lo que no hay ningún beneficio de ninguna manera. PostgreSQL y SQL Server no atajan esto; Se lee como aparece arriba.
El estándar ANSI SQL define <> como el operador "no es igual a",
http://www.contrib.andrew.cmu.edu/~shadow/sql/sql1992.txt ( 5.2 <token> and <separator> )
No hay un operador != Según el estándar ANSI / SQL 92.
Entiendo que la sintaxis C != está en SQL Server debido a su herencia de Unix (en los días de Sybase SQL Server, antes de Microsoft SQL Server 6.5).
La mayoría de las bases de datos admiten != (Lenguajes de programación populares) y <> (ANSI).
Bases de datos que soportan tanto != <> :
- 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 soportan el operador estándar ANSI, exclusivamente :
Parece que los mismos Microsoft prefieren <> a != Como se evidencia en sus restricciones de tabla. Personalmente prefiero usar != Porque lo leí claramente como "no igual", pero si ingresas [field1 != field2] y lo guardas como un [field1 != field2] , la próxima vez que lo consultes, aparecerá como [field1 <> field2] . Esto me dice que la forma correcta de hacerlo es <> .
Prefiero usar != 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.
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 la base de datos parecen preferir <> .
Técnicamente funcionan de la misma manera si estás utilizando SQL Server AKA T-SQL. Si lo está utilizando en procedimientos almacenados, no hay ninguna razón de rendimiento para usar uno sobre el otro. Luego se reduce a las preferencias personales. Prefiero usar <> ya que es compatible con ANSI.
Puede encontrar enlaces a los distintos estándares ANSI en ...
Una alternativa sería usar el operador NULLIF que no sea <> o != Que devuelve NULL si los dos argumentos son NULLIF iguales en Microsoft Docs . Así que creo que la cláusula WHERE se puede modificar para <> y != siguiente manera:
NULLIF(arg1, arg2) IS NOT NULL
Como descubrí que, usar <> y != No funciona para la fecha en algunos casos. Por lo tanto, usar la expresión anterior hace lo necesario.
!= , 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 extraño. Sé que la intención es que sea menor o mayor que, por lo tanto, no es igual, pero esa es una manera realmente complicada de decir algo realmente simple.
Simplemente tuve que tomar algunas consultas SQL largas y colocarlas con amor en un archivo XML por un montón de razones estúpidas en las que no voy a entrar.
Basta con decir que XML no está mal con <> en absoluto y tuve que cambiarlos por != Y comprobarme antes de que me arruinaran.
<> es el SQL válido según el estándar SQL-92.
http://msdn.microsoft.com/en-us/library/aa276846(SQL.80).aspx
''<>'' es del estándar SQL-92 y ''!='' es un operador proprietary 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 su SQL.