ฉันควรใช้! = หรือ <> เพื่อไม่เท่ากันใน T-SQL หรือไม่

800

ฉันได้เห็นSQLว่าการใช้งานทั้งใน!=และ<>สำหรับไม่เท่ากัน ไวยากรณ์ที่ต้องการคืออะไรและเพราะเหตุใด

ผมชอบ!=เพราะทำให้ผมนึกถึง<>Visual Basic

sql sql-server tsql

5

ดูเพิ่มเติมที่: stackoverflow.com/questions/7884/…

— ดินาห์

การพกพาของรหัส หากความต้องการของคุณตรงตามมาตรฐาน ANSI SQL คุณควรใช้มัน คุณสามารถใช้รหัสเดียวกันในฐานข้อมูลทั้งหมด เช่น. ผู้แต่งหนังสือ SQL ที่ต้องการแสดง SQL พื้นฐานโดยใช้โค้ดตัวอย่าง

— Steam

1

ฉันต้องการเพิ่มตัวอย่างที่มีเพียงรหัส ANSI SQL เท่านั้นที่เป็นปัญหา - SQL มาตรฐานรองรับตัวเลือก NULLS FIRST และ NULLS LAST เพื่อควบคุมวิธีการจัดเรียง NULLs แต่ T-SQL ไม่สนับสนุนตัวเลือกนี้

— Steam

ไม่จำเป็นต้องเปิดใหม่อีกครั้ง NOT (A = B)คำถามที่มีการทำเครื่องหมายเป็นซ้ำเพียงขยายออกไปโดยยังมีตัวเลือกมากขึ้นอย่างใดอย่างหนึ่ง

— TLama

@ ทีมคุณควรระบุเวอร์ชันปีของ ansi sql ที่คุณอ้างอิงอย่างแน่นอน บางรุ่นเหล่านี้ยังต้องการให้คุณระบุระดับความเข้ากันได้หรือส่วนที่แน่นอนของรูปแบบ คนไหนที่แนะนำ NULLS FIRST และ NULLS LAST

— Gherman

539

ในทางเทคนิคมันทำงานเหมือนกันถ้าคุณใช้ SQL Server AKA T-SQL หากคุณกำลังใช้งานในขั้นตอนการจัดเก็บไม่มีเหตุผลด้านประสิทธิภาพในการใช้อีกแบบหนึ่ง จากนั้นจะลงมาตามความชอบส่วนตัว ฉันชอบที่จะใช้ <> เนื่องจากเป็นไปตามมาตรฐาน ANSI

คุณสามารถค้นหาลิงก์ไปยังมาตรฐาน ANSI ต่างๆได้ที่ ...

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

— DBAndrew
แหล่งที่มา

41

ผมได้แนะนำเสมอที่จะใช้!=เพราะของการดำรงอยู่ในทุกภาษา C-อิทธิพลฉันได้ใช้และเนื่องจากเอกสารงูใหญ่กล่าวว่า "รูปแบบ<>และ!=มีเทียบเท่าสำหรับความสอดคล้องกับ C, !=เป็นที่ต้องการที่ซึ่ง!=เป็นที่กล่าวถึงด้านล่าง<>นอกจากนี้ยังได้รับการยอมรับ การ<>สะกดคำนี้ถือว่าล้าสมัย " แต่ SQL ไม่ใช่ Python!

— เอียนซามูเอลแมคลีนเลน

24

ฉันชอบใช้ <> เพราะมันทำให้ฉันนึกถึง XML แต่ SQL ไม่ใช่ XML!

— Rob Grant

32

ใช่; ไมโครซอฟท์ขอแนะนำให้ใช้ตัวเอง<>มากกว่า!=โดยเฉพาะสำหรับการปฏิบัติตามมาตรฐาน ANSI เช่นในชุดฝึกอบรม Microsoft ข่าวสำหรับ 70-461 สอบ "สอบถาม Microsoft SQL Server" พวกเขากล่าวว่า "ในฐานะที่เป็นตัวอย่างเมื่อจะเลือกรูปแบบมาตรฐาน T-SQL สนับสนุนสอง“ไม่ได้ เท่ากับ” ตัวดำเนินการ: <> และ! = อดีตคือมาตรฐานและไม่หลังกรณีนี้ควรเป็นตัวกรอง: ไปหามาตรฐาน! "

— Matt Gibson

10

ฉันชอบ <> เพราะพิมพ์ง่ายกว่า

— user2023861

731

ฐานข้อมูลส่วนใหญ่รองรับ!=(ภาษาโปรแกรมที่เป็นที่นิยม) และ<>(ANSI)

ฐานข้อมูลที่รองรับทั้ง!=และ<>:

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

ฐานข้อมูลที่รองรับตัวดำเนินการมาตรฐาน ANSI โดยเฉพาะ :

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

— Bill Karwin
แหล่งที่มา

แบบสอบถาม Django ออมแมปไปNOT (a = b)แทนหรือ(a <> b) (a != b)ภายในเหมือนกันหรือไม่

— ผู้ใช้

7

@buffer พวกมันมีเหตุผลเหมือนกันนั่นคือมันจะจับคู่หรือแยกแถวชุดเดียวกัน แต่ไม่ว่าแบรนด์ RDBMS จะปรับให้เหมาะสมหรือไม่นั้นขึ้นอยู่กับการนำไปใช้งาน ที่กล่าวว่าฉันจะแปลกใจถ้ามีความแตกต่างระหว่างแบรนด์ของฐานข้อมูล

— Bill Karwin

หมายเหตุด้านข้าง: LINQ ใน C # คุณต้องใช้! =

— Tom Stickel

! = ได้รับการสนับสนุนโดย IBM DB2 LUW 10.5+

— Cristi S.

10

@TomStickel LINQ ใน C # ไม่ใช่ SQL

— เครก

109

'<>'มาจากมาตรฐานSQL-92และ'!='เป็นผู้ดำเนินการ T-SQL ที่เป็นกรรมสิทธิ์ มันมีอยู่ในฐานข้อมูลอื่นด้วยเช่นกัน แต่เนื่องจากมันไม่ได้มาตรฐานคุณจึงต้องใช้มันเป็นกรณี ๆ ไป

ในกรณีส่วนใหญ่คุณจะรู้ว่าคุณกำลังเชื่อมต่อกับฐานข้อมูลใดจึงไม่เป็นปัญหา ที่แย่ที่สุดคุณอาจต้องทำการค้นหาและแทนที่ใน SQL ของคุณ

— Adam Lassek
แหล่งที่มา

ฉันได้เห็น mysql sql ก็ใช้มันเช่นกัน

— Bob The Janitor

3

เราสามารถโทรหาส่วนขยายที่แพร่หลายไปยังภาษามาตรฐานที่เป็นกรรมสิทธิ์ได้หรือไม่? ณ จุดนี้ดูเหมือนว่ามาตรฐานควรได้รับการอัปเดตเป็นที่ต้องการหรืออย่างน้อยก็อนุญาตให้มีทั้งไวยากรณ์

— Johan Boulé

3

@JohanBoule ดีมีมาตรฐานเป็นลายลักษณ์อักษรสำหรับ SQL และความรู้ของฉัน!=ไม่ได้เป็นส่วนหนึ่งของมัน แม้ว่ามันจะเป็นมาตรฐานที่ปฏิบัติได้จริง แต่เราก็ไม่ควรสร้างความสับสนให้กับสิ่งที่และไม่ใช่คุณสมบัติมาตรฐาน

— Adam Lassek

43

มาตรฐาน ANSI SQL กำหนด<>เป็นตัวดำเนินการ "ไม่เท่ากับ"

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

ไม่มี!=ตัวดำเนินการตามมาตรฐาน ANSI / SQL 92

— Mehrdad Afshari
แหล่งที่มา

36

<> เป็น SQL ที่ถูกต้องตามมาตรฐาน SQL-92

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

— Justin Niessner
แหล่งที่มา

3

ทั้งสองถูกต้อง แต่ '<>' เป็นมาตรฐานของ SQL-92

— จัสติน Niessner

24

พวกเขาทั้งที่ถูกต้องและที่เหมือนกันด้วยความเคารพในSQL Server ,

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

— madcolor
แหล่งที่มา

นั่นคือ SQL Server เฉพาะ ได้รับเขาถามเกี่ยวกับ SQL Server แต่คุณสามารถค้นหาการอ้างอิงข้อมูลจำเพาะ ANSI เพื่อดูว่ามันรับประกันว่าจะพกพาได้สำหรับพวกเราที่ต้องการทราบสิ่งนั้นหรือไม่

— Joel Coehoorn

6

@ Joel Coehoorn ถ้าคุณย้ายรหัส T-SQL ของคุณไป "<>" และ "! =" จะเป็นสิ่งที่คุณกังวลน้อยที่สุด !!

— กม.

1

การย้ายไม่ใช่ปัญหา แต่เมื่อคุณเป็นนักพัฒนาคุณต้องย้อนกลับไปมาระหว่างสภาพแวดล้อม ความสอดคล้องเป็นสิ่งที่ดี

— Mark Ransom

20

ดูเหมือนว่า Microsoft เองชอบที่<>จะ!=เป็นหลักฐานในข้อ จำกัด ตารางของพวกเขา ผมเองชอบใช้!=เพราะผมอย่างชัดเจนอ่านว่าเป็น "ไม่เท่ากัน" แต่ถ้าคุณใส่[field1 != field2]และบันทึกเป็น constrait [field1 <> field2]ที่ครั้งต่อไปที่คุณสอบถามมันจะแสดงเป็น <>นี้บอกกับผมว่าวิธีที่ถูกต้องที่จะทำคือ

— ไคล์
แหล่งที่มา

15

!=แม้จะไม่ใช่ ANSI แต่จิตวิญญาณที่แท้จริงของ SQL ก็เป็นภาษาที่อ่านได้มากกว่า มันกรีดร้องไม่เท่ากัน <>บอกฉันว่า (น้อยกว่ามาก) ซึ่งแปลกมาก ฉันรู้ว่าความตั้งใจคือว่ามันน้อยกว่าหรือมากกว่านั้นไม่เท่ากัน แต่นั่นเป็นวิธีที่ซับซ้อนมากในการพูดบางสิ่งที่เรียบง่ายจริงๆ

ฉันเพิ่งจะต้องใช้แบบสอบถาม SQL ยาว ๆ และวางลงในไฟล์ XML ด้วยความรักด้วยเหตุผลโง่ ๆ มากมายที่ฉันจะไม่เข้าไป

พอเพียงที่จะบอกว่า XML นั้นไม่ได้ลดลง<>เลยและฉันต้องเปลี่ยนพวกเขาเป็น!=และตรวจสอบตัวเองก่อนที่ฉันจะทำลายตัวเอง

— อัลเบิร์ตไขมัน
แหล่งที่มา

6

ทำไมไม่ใช่แค่ CDATA? จะเกิดอะไรขึ้นเมื่อข้อความค้นหาของคุณมี XML

— Janus Troelsen

12

คุณสามารถใช้สิ่งที่คุณต้องการใน T-SQL เอกสารกล่าวว่าพวกเขาทั้งสองทำงานในลักษณะเดียวกัน ฉันชอบ!=เพราะมันอ่าน "ไม่เท่ากัน" เพื่อ (C / C ++ / C # based) ใจของฉัน <>แต่ผู้เชี่ยวชาญด้านฐานข้อมูลดูเหมือนจะชอบ

— สตีฟ
แหล่งที่มา

10

ฉันเข้าใจว่าไวยากรณ์ C !=อยู่ใน SQL Server เนื่องจาก Unix Heritage (ย้อนกลับไปใน Sybase SQL Server วันก่อน Microsoft SQL Server 6.5)

— คาร์ล
แหล่งที่มา

7

อีกทางเลือกหนึ่งคือการใช้ตัวดำเนินการ NULLIF นอกเหนือจาก<>หรือ!=ซึ่งคืนค่า NULL ถ้าอาร์กิวเมนต์สองตัวมีค่าเท่ากับNULLIF ใน Microsoft Docsเอกสาร ดังนั้นฉันเชื่อว่าคำสั่ง WHERE สามารถแก้ไขได้<>และ!=ดังนี้

NULLIF(arg1, arg2) IS NOT NULL

อย่างที่ฉันพบว่าการใช้งาน<>และ!=ไม่สามารถทำงานได้ในบางกรณี ดังนั้นการใช้นิพจน์ด้านบนจึงไม่จำเป็น

— jitendrapurohit
แหล่งที่มา

6

ฉันไม่แน่ใจว่าฟังก์ชั่นนี้จะทำงานได้ดี<>เท่ากับการใช้ดัชนีในทุกกรณีหรือไม่ นอกจากนี้ความสามารถในการอ่านนั้นแย่ยิ่งกว่าเดิมมาก ...

— Lukas Eder

อย่างที่ฉันพูดถึงในคำตอบสิ่งนี้ใช้ได้กับฉันในช่องวันที่กลับมาในปี 2014 ไม่แน่ใจว่าประโยค / เงื่อนไขใดที่ จำกัด คำตอบอื่น ๆ แต่การดู upvotes บางอย่างดูเหมือนจะช่วยผู้อื่นด้วย

— jitendrapurohit

1

ฉันต้องการใช้!=แทน<>เพราะบางครั้งฉันใช้<s></s>ไวยากรณ์เพื่อเขียนคำสั่ง SQL การใช้!=สะดวกกว่าเพื่อหลีกเลี่ยงข้อผิดพลาดทางไวยากรณ์ในกรณีนี้

— Andrea Antonangeli
แหล่งที่มา

-6

พวกเขาทั้งสองได้รับการยอมรับใน T-SQL อย่างไรก็ตามดูเหมือนว่าการใช้<>งานจะเร็วกว่า!=มาก ฉันเพิ่งเรียกใช้แบบสอบถามที่ซับซ้อนที่ใช้!=และใช้เวลาประมาณ 16 วินาทีโดยเฉลี่ยในการทำงาน ฉันเปลี่ยนสิ่งเหล่านี้เป็น<>และแบบสอบถามตอนนี้ใช้เวลาโดยเฉลี่ยประมาณ 4 วินาทีในการเรียกใช้ นั่นเป็นการปรับปรุงครั้งใหญ่!

— หมู่บ้าน Javier
แหล่งที่มา

20

ถ้าคุณเรียกใช้แบบสอบถามที่คล้ายกันสองรายการซึ่งอยู่ติดกันใน SQL Server นั้นจะมีข้อมูลแคชในหน่วยความจำและปรับให้เหมาะสำหรับแบบสอบถามที่คล้ายกัน หากคุณทำตามลำดับย้อนกลับคุณอาจพบผลลัพธ์ตรงกันข้าม!

— codemonkey

2

นี่เป็นความผิดพวกเขาจะไม่มีตัวดำเนินการสองตัวที่ทำหน้าที่เหมือนกันและตัวหนึ่งทำงานช้ากว่า "สาเหตุ" มีหลายปัจจัยที่ทำให้เหตุผลที่แบบสอบถามเดียวกันจะสร้างเวลาดำเนินการที่แตกต่างกัน

— Elliot Chance

-11

แม้ว่าพวกเขาจะทำงานในลักษณะเดียวกัน!=หมายความว่า "ไม่เท่ากับ" ในขณะที่<>หมายถึงมากกว่าและน้อยกว่าค่าที่เก็บไว้

พิจารณา>=หรือ<=และสิ่งนี้จะสมเหตุสมผลเมื่อแฟคตอริ่งในดัชนีของคุณไปยังคิวรี ... <>จะทำงานได้เร็วขึ้นในบางกรณี (ด้วยดัชนีที่ถูกต้อง) แต่ในบางกรณี (ดัชนีฟรี) พวกเขาจะทำงานเหมือนเดิม

นอกจากนี้ยังขึ้นอยู่กับวิธีการที่ระบบฐานข้อมูลของคุณอ่านค่าและ!= <>ผู้ให้บริการฐานข้อมูลอาจทำการลัดและทำให้มันทำงานเหมือนกันดังนั้นจึงไม่มีผลประโยชน์ใด ๆ ทั้งทาง PostgreSQL และ SQL Server จะไม่ทำสิ่งนี้ อ่านตามที่ปรากฏด้านบน

— Kevin Kinchen
แหล่งที่มา

3

คุณมีข้อมูลอ้างอิงที่สนับสนุนคำสั่งของคุณหรือไม่? ผู้ประกอบการทั้งสองดูเหมือนจะตรงเดียวกันในPostgreSQL , ออราเคิลและMySQL

— GhostGambler

8

นี่เป็นสิ่งที่ผิดอย่างสิ้นเชิงมันอาจดูเหมือนว่าคุณ "มากกว่าและน้อยกว่าค่าที่เก็บไว้" เมื่อคุณรวมตัวละครเหล่านั้นในใจของคุณ

— Elliot Chance

ขาดทรัพยากรที่เกี่ยวข้อง!

— mostafa8026