Dovrei usare! = O <> per non uguale in T-SQL?

Ho visto SQLche usa entrambi !=e <>per non essere uguali . Qual è la sintassi preferita e perché?

Mi piace !=, perché <>mi ricorda Visual Basic.

Tecnicamente funzionano allo stesso modo se si utilizza SQL Server AKA T-SQL. Se lo si utilizza nelle procedure memorizzate, non vi è alcun motivo di prestazioni da utilizzare l'uno sull'altro. Si riduce quindi alle preferenze personali. Preferisco usare <> in quanto è conforme ANSI.

Puoi trovare link ai vari standard ANSI su ...

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

La maggior parte dei database supporta !=(linguaggi di programmazione popolari) e <>(ANSI).

Database che supportano entrambi !=e <>:

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

Database che supportano l'operatore standard ANSI, esclusivamente :

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

'<>'proviene dallo standard SQL-92 ed '!='è un operatore proprietario T-SQL. È disponibile anche in altri database, ma poiché non è standard è necessario prenderlo caso per caso.

Nella maggior parte dei casi, saprai a quale database ti stai connettendo, quindi questo non è davvero un problema. Nel peggiore dei casi potresti dover effettuare una ricerca e sostituirla nel tuo SQL.

Lo standard SQL ANSI definisce <>l'operatore "non uguale a",

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

Non esiste alcun !=operatore secondo lo standard ANSI / SQL 92.

<> è l'SQL valido secondo lo standard SQL-92.

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

Sono entrambi validi e uguali rispetto a SQL Server ,

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

Sembra che Microsoft si preferiscono <>a !=come evidenziato nei loro vincoli di tabella. Personalmente preferisco usarlo !=perché l'ho letto chiaramente come "non uguale", ma se lo inserisci [field1 != field2]e lo salvi come un punto di forza, la prossima volta che lo interrogherai, verrà visualizzato come [field1 <> field2]. Questo mi dice che il modo corretto di farlo è <>.

!=, pur non essendo ANSI, è più nel vero spirito di SQL come linguaggio leggibile. Urla non uguale. <>dice che è per me (minore di, maggiore di) che è semplicemente strano. So che l'intenzione è che sia minore o maggiore di quindi non uguale, ma questo è un modo davvero complicato di dire qualcosa di veramente semplice.

Ho dovuto solo prendere alcune lunghe query SQL e inserirle amorevolmente in un file XML per tutta una serie di stupide ragioni che non affronterò.

Basti pensare che l'XML non è affatto negativo <>e ho dovuto cambiarli !=e controllarmi prima di distruggermi.

Puoi usare quello che preferisci in T-SQL. La documentazione afferma che entrambi funzionano allo stesso modo. Preferisco !=, perché legge "non uguale" alla mia mente (basata su C / C ++ / C #), ma i guru del database sembrano preferire <>.

Comprendo che la sintassi C si !=trova in SQL Server a causa della sua eredità Unix (ai tempi di Sybase SQL Server, pre Microsoft SQL Server 6.5).

Un'alternativa sarebbe quella di utilizzare l'operatore NULLIF diverso <>o !=che restituisce NULL se i due argomenti sono uguali NULLIF in Microsoft Docs . Quindi credo che la clausola WHERE possa essere modificata per <>e !=come segue:

NULLIF(arg1, arg2) IS NOT NULL

Come ho scoperto, in alcuni casi l' utilizzo <>e la !=data non funzionano per data. Quindi usare l'espressione sopra fa il necessario.

Ho preferito usare !=invece di <>perché a volte uso la <s></s>sintassi per scrivere comandi SQL. L'uso !=è più utile per evitare errori di sintassi in questo caso.

Entrambi sono accettati in T-SQL. Tuttavia, sembra che l'utilizzo funzioni <>molto più velocemente di!= . Ho appena eseguito una query complessa che stava utilizzando !=e ci sono voluti in media circa 16 secondi per l'esecuzione. Ho cambiato quelli in <>e la query ora richiede circa 4 secondi in media per l'esecuzione. Questo è un enorme miglioramento!

Sebbene funzionino allo stesso modo, !=significa esattamente "non uguale a", mentre<> significa maggiore e minore del valore memorizzato.

Prendi in considerazione >=o <=, e questo avrà senso quando il factoring nei tuoi indici alle query ... <>funzionerà più velocemente in alcuni casi (con l'indice giusto), ma in altri casi (senza indice) funzioneranno allo stesso modo.

Ciò dipende anche da come il sistema di database legge i valori !=e <>. Il provider del database può semplicemente collegarlo e farli funzionare allo stesso modo, quindi non ci sono vantaggi in entrambi i modi. PostgreSQL e SQL Server non lo fanno; viene letto come appare sopra.