Dois-je utiliser!= ou pour ne pas égaux en T-SQL?

la Plupart des bases de données de soutien != (les langages de programmation courants) et <> (ANSI).

bases de données supportant à la fois != et <> :

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

bases de données qui supportent l'opérateur standard ANSI, exclusivement :

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

'<>' est de la standard SQL-92 et '!=' est un propriétaire t-opérateur SQL. Il est disponible dans d'autres bases de données, mais comme il n'est pas standard, vous devez le prendre au cas par cas.

dans la plupart des cas, vous savez à quelle base de données vous vous connectez donc ce n'est pas vraiment un problème. Au pire, vous pourriez avoir à faire une recherche et remplacer dans votre SQL.

la norme ANSI SQL définit <> comme" n'égale pas "l'opérateur,

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

il n'y a pas d'opérateur != selon la norme ANSI/SQL 92.

<> est le SQL valide selon la norme SQL-92.

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

ils sont à la fois valides et identiques en ce qui concerne SQL Server ,

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

il semble que Microsoft eux-mêmes préfèrent <> à != comme en témoignent leurs contraintes de tableau. Personnellement, je préfère utiliser != parce que j'ai clairement lu que "pas égal", mais si vous entrez [field1 != field2] et sauvegardez-le comme une contrainte, la prochaine fois que vous le questionnez, il apparaîtra comme [field1 <> field2] . Cela me dit que la bonne façon de le faire est <> .

!= , bien que n'étant pas ANSI, est plus dans le véritable esprit de SQL comme un langage lisible. Il crie n'est pas égal. <> dit que c'est à moi (inférieur, supérieur) qui est juste bizarre. Je sais que l'intention est que ce soit moins que ou plus grand que donc pas égal, mais c'est une façon très compliquée de dire quelque chose de vraiment simple.

j'ai juste eu à prendre quelques longues requêtes SQL et les placer avec amour dans un fichier XML pour un tas entier de stupides raisons pour lesquelles je n'entrerai pas dans les.

suffit de dire XML n'est pas du tout avec <> et j'ai dû les changer en != et ME vérifier avant que je riggedy s'est ruiné.

vous pouvez utiliser celui que vous voulez dans T-SQL. La documentation dit ils ont tous deux fonctionnent de la même manière. Je préfère != , parce qu'il lit" pas égal "à mon (C/C++/C# basé) esprit, mais les gourous de base de données semblent préférer <> .

je comprends que la syntaxe C != est en SQL Server en raison de son héritage Unix (retour dans le Sybase SQL Server days, pré Microsoft SQL Server 6.5).

une alternative serait d'utiliser L'opérateur NULLIF autre que <> ou != qui renvoie NULL si les deux arguments sont égaux NULLIF dans Microsoft Docs . Donc je crois que la clause peut être modifiée pour <> et != comme suit:

NULLIF(arg1, arg2) IS NOT NULL

que j'ai découvert ce, à l'aide de <> et != ne fonctionne pas pour la date dans certains cas. Par conséquent, l'utilisation de l'expression ci-dessus needful.

j'ai préféré utiliser != au lieu de <> parce que parfois j'utilise la syntaxe <s></s> pour écrire des commandes SQL. L'utilisation de != est plus pratique pour éviter les erreurs de syntaxe dans ce cas.

ils sont tous les deux acceptés en T-SQL. Cependant, il semble que l'utilisation de <> fonctionne beaucoup plus rapidement que != . Je viens de lancer une requête complexe qui utilisait != , et il a fallu environ 16 secondes en moyenne pour lancer. Je les ai changées en <> et la requête prend maintenant environ 4 secondes en moyenne pour s'exécuter. C'est une énorme amélioration!

bien qu'ils fonctionnent de la même façon, != signifie exactement" pas égal à", tandis que <> signifie supérieur et inférieur à la valeur stockée.

prendre en considération >= ou <= , et cela a du sens lorsque l'affacturage dans votre index pour les requêtes... <> courir plus vite dans certains cas (avec l'index droit), mais dans d'autres cas (indice de libre), ils vont courir tout de même.

Cela dépend aussi de la façon dont votre bases de données système lit les valeurs != et <> . Le fournisseur de base de données peut simplement le raccourcir et les faire fonctionner de la même façon, donc il n'y a aucun avantage de toute façon. PostgreSQL et SQL Server ne raccourcissent pas cela; il est lu tel qu'il apparaît ci-dessus.