Haruskah saya menggunakan! = Atau <> karena tidak sama dengan T-SQL?

Saya telah melihat SQLbahwa penggunaan baik !=dan <>untuk tidak sama . Apa sintaks yang disukai dan mengapa?

Saya suka !=, karena <>mengingatkan saya pada Visual Basic.

Secara teknis mereka berfungsi sama jika Anda menggunakan SQL Server AKA T-SQL. Jika Anda menggunakannya dalam prosedur tersimpan, tidak ada alasan kinerja untuk menggunakannya. Kemudian turun ke preferensi pribadi. Saya lebih suka menggunakan <> karena sesuai dengan ANSI.

Anda dapat menemukan tautan ke berbagai standar ANSI di ...

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

Sebagian besar basis data mendukung !=(bahasa pemrograman populer) dan <>(ANSI).

Database yang mendukung keduanya !=dan <>:

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

Basis data yang mendukung operator standar ANSI, secara eksklusif :

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

'<>'berasal dari standar SQL-92 dan '!='merupakan operator T-SQL berpemilik . Ini tersedia di database lain juga, tetapi karena itu bukan standar Anda harus mengambilnya berdasarkan kasus per kasus.

Dalam kebanyakan kasus, Anda akan tahu database apa yang Anda hubungkan sehingga ini bukan masalah. Paling buruk Anda mungkin harus melakukan pencarian dan ganti dalam SQL Anda.

ANSI SQL Standard didefinisikan <>sebagai operator "tidak sama dengan",

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

Tidak ada !=operator sesuai dengan standar ANSI / SQL 92.

<> adalah SQL yang valid sesuai dengan standar SQL-92.

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

Keduanya valid dan sama sehubungan dengan SQL Server ,

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

Tampaknya Microsoft sendiri lebih memilih <>untuk !=dibuktikan di kendala meja mereka. Saya pribadi lebih suka menggunakan !=karena saya dengan jelas membacanya sebagai "tidak sama", tetapi jika Anda memasukkan [field1 != field2]dan menyimpannya sebagai constrait, kali berikutnya Anda meminta, itu akan muncul sebagai [field1 <> field2]. Ini mengatakan kepada saya bahwa cara yang benar untuk melakukannya adalah <>.

!=, Meskipun non-ANSI, lebih dalam semangat sebenarnya dari SQL sebagai bahasa yang dapat dibaca. Jeritannya tidak sama. <>mengatakan itu padaku (kurang dari, lebih besar dari) yang aneh. Saya tahu tujuannya adalah bahwa itu kurang dari atau lebih besar dari itu tidak sama, tapi itu cara yang sangat rumit untuk mengatakan sesuatu yang sangat sederhana.

Saya baru saja harus mengambil beberapa pertanyaan SQL panjang dan menempatkannya dengan penuh kasih ke dalam file XML untuk sejumlah alasan bodoh saya tidak akan masuk ke.

Cukuplah untuk mengatakan XML tidak down <>sama sekali dan saya harus mengubahnya !=dan memeriksa diri saya sebelum saya dengan susah payah menghancurkan diri saya sendiri.

Anda dapat menggunakan mana yang Anda suka di T-SQL. Dokumentasi mengatakan keduanya berfungsi dengan cara yang sama. Saya lebih suka !=, karena berbunyi "tidak sama" dengan pikiran saya (C / C ++ / C #), tetapi guru basis data tampaknya lebih suka <>.

Saya mengerti bahwa sintaks C !=dalam SQL Server karena warisan Unix (kembali pada hari-hari Sybase SQL Server, sebelum Microsoft SQL Server 6.5).

Salah satu alternatifnya adalah menggunakan operator NULLIF selain <>atau !=yang mengembalikan NULL jika kedua argumen tersebut sama dengan NULLIF di Microsoft Documents . Jadi saya percaya klausa WHERE dapat dimodifikasi untuk <>dan !=sebagai berikut:

NULLIF(arg1, arg2) IS NOT NULL

Ketika saya menemukan itu, menggunakan <>dan !=tidak berfungsi untuk tanggal dalam beberapa kasus. Oleh karena itu menggunakan ungkapan di atas tidak perlu.

Saya lebih suka menggunakan !=daripada <>karena kadang-kadang saya menggunakan <s></s>sintaks untuk menulis perintah SQL. Menggunakan !=lebih berguna untuk menghindari kesalahan sintaksis dalam kasus ini.

Keduanya diterima dalam T-SQL. Namun, tampaknya menggunakan <>jauh lebih cepat daripada menggunakan!= . Saya baru saja menjalankan kueri kompleks yang digunakan !=, dan butuh rata-rata sekitar 16 detik untuk berjalan. Saya mengubahnya menjadi <>dan permintaan sekarang rata-rata berjalan sekitar 4 detik. Itu peningkatan besar!

Meskipun mereka berfungsi dengan cara yang sama, !=berarti persis "tidak sama dengan", sementara itu <>berarti lebih dari dan kurang dari nilai yang disimpan.

Pertimbangkan >=atau <=, dan ini akan masuk akal ketika memfaktorkan dalam indeks Anda ke kueri ... <>akan berjalan lebih cepat dalam beberapa kasus (dengan indeks yang tepat), tetapi dalam beberapa kasus lain (bebas indeks) mereka akan berjalan sama saja.

Ini juga tergantung pada bagaimana sistem database Anda membaca nilai !=dan <>. Penyedia basis data dapat memintasnya dan membuatnya berfungsi sama, jadi tidak ada manfaatnya. PostgreSQL dan SQL Server tidak memintaskan ini; itu dibaca seperti yang muncul di atas.