Dois-je utiliser! = Ou <> pour différent de T-SQL?
J'ai vu SQL qui utilise à la fois != et <> pour différent de . Quelle est la syntaxe préférée et pourquoi?
J'aime bien !=, parce que <> me fait penser à Visual Basic.
Techniquement, ils fonctionnent de la même manière si vous utilisez SQL Server AKA T-SQL. Si vous l'utilisez dans des procédures stockées, il n'y a aucune raison de performance pour utiliser l'une sur l'autre. Cela revient ensuite à vos préférences personnelles. Je préfère utiliser <> car il est conforme à la norme ANSI.
Vous pouvez trouver des liens vers les différentes normes ANSI sur ...
La plupart des bases de données prennent en charge _!=_ (langages de programmation courants) et _<>_ (ANSI).
Bases de données prenant en charge à 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 prenant en charge l'opérateur standard ANSI, exclusivement :
'<>' provient du standard SQL-92 et '!=' est un opérateur propriétaire T-SQL. Il est également disponible dans d'autres bases de données, mais comme ce n'est pas standard, vous devez le prendre au cas par cas.
Dans la plupart des cas, vous saurez à quelle base de données vous vous connectez, ce n'est donc pas vraiment un problème. Dans le pire des cas, vous devrez peut-être effectuer une recherche et la remplacer dans votre code SQL.
La norme ANSI SQL définit <> comme étant l'opérateur "différent de",
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 code SQL valide conforme à la norme SQL-92.
http://msdn.Microsoft.com/en-us/library/aa276846 (SQL.80) .aspx
Ils sont tous deux 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 lui-même préfère <> à !=, comme l'indiquent leurs contraintes de table. Personnellement, je préfère utiliser != parce que je lis clairement que "non égal", mais si vous entrez [field1 != field2] et le sauvegardez en tant que constrait, la prochaine fois que vous l'interrogerez, il apparaîtra comme [field1 <> field2]. Cela me dit que la bonne façon de le faire est <>.
!=, bien que non-ANSI, est davantage dans le véritable esprit de SQL en tant que langage lisible. Ça crie pas égal. <> dit que c'est pour moi (moins que, plus grand que) ce qui est juste étrange. Je sais que l’intention est que ce soit inférieur ou supérieur par conséquent pas égal, mais c’est une façon très compliquée de dire quelque chose de vraiment simple.
Je viens juste de prendre de longues requêtes SQL et de les placer avec amour dans un fichier XML pour toutes sortes de raisons stupides dans lesquelles je n'entrerai pas.
Disons simplement que XML n’a pas du tout recours à <> et que j’ai dû les remplacer par != et me vérifier avant de me détruire.
Vous pouvez utiliser ce que vous voulez dans T-SQL. La documentation dit que les deux fonctionnent de la même manière. Je préfère !=, car il se lit "pas égal" à mon esprit (basé sur C/C++/C #), mais les gourous de la base de données semblent préférer <>.
Je comprends que la syntaxe C != se trouve dans SQL Server en raison de son héritage Unix (à l'époque de Sybase SQL Server, antérieure à 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 . Je pense donc que la clause WHERE peut être modifiée pour <> et != comme suit:
NULLIF(arg1, arg2) IS NOT NULL
Comme je l'ai constaté, utiliser <> et != ne fonctionne pas pour la date dans certains cas. Par conséquent, utiliser l'expression ci-dessus fait le nécessaire.
J'ai préféré utiliser != au lieu de <> parce que j'utilise parfois la syntaxe <s></s> pour écrire des commandes SQL. Utiliser != est plus pratique pour éviter les erreurs de syntaxe dans ce cas.