# คู่มือปฏิบัติเกี่ยวกับตรรกะ If-Else-If ใน SQL ด้วยคำสั่ง CASE และ IF

> เรียนรู้ตรรกะ if-else-if ใน SQL อย่างเชี่ยวชาญ คู่มือของเราจะอธิบายพร้อมตัวอย่างเชิงปฏิบัติถึงวิธีการใช้ CASE และ IF เพื่อแปลงข้อมูลใน MySQL และ SQL Server

Source: https://www.electe.net/th/post/if-else-if-in-sql

Site guide: https://www.electe.net/th/llms.txt

หลายคนที่คุ้นเคยกับภาษาโปรแกรมมิ่งอื่น มักสงสัยว่าจะจำลองคำสั่งคลาสสิก `IF ELSE IF` ใน SQL ได้อย่างไร คำตอบคือ SQL ไม่มีคำสั่งโดยตรงที่ใช้ชื่อนี้ แต่มีทางออกที่ทรงพลังและสง่างามยิ่งกว่า นั่นคือนิพจน์ **CASE WHEN** นี่คือวิธีมาตรฐานและเป็นสากลสำหรับการจัดการเงื่อนไขหลายรายการโดยตรงภายในคิวรีของคุณ นอกจาก `CASE` แล้ว บางไดอะเล็กต์อย่าง T-SQL และ MySQL ยังมีทางลัดที่กระชับกว่าให้ใช้ เช่น `IIF()` และ `IF()` สำหรับกรณีที่ง่ายกว่า

## เหตุใดตรรกะแบบมีเงื่อนไขจึงเป็นพลังอันน่าทึ่งใน SQL

ลองนึกภาพว่าคุณต้องแบ่งกลุ่มลูกค้าตามช่วงกำลังซื้อ จัดลำดับความสำคัญของคำขอความช่วยเหลือตามความเร่งด่วน หรือติดป้ายกำกับผลิตภัณฑ์ตามฤดูกาล คุณคงอยากทำทั้งหมดนี้โดยตรงในฐานข้อมูล โดยไม่ต้องส่งออกข้อมูลและประมวลผลที่อื่นใช่ไหม?

นี่คือพลังที่แท้จริงของตรรกะแบบมีเงื่อนไขใน SQL บรรทัดโค้ดนั้นเองที่เปลี่ยนการดึงข้อมูลธรรมดาให้กลายเป็นการวิเคราะห์ทางธุรกิจที่แท้จริง

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

แทนที่จะดึงข้อมูลดิบออกมาแล้วป้อนเข้าไปใน Excel หรือ Python คุณจะได้เรียนรู้วิธี:

- **สร้างข้อมูลเชิงลึกที่ซับซ้อน** ได้ตั้งแต่ระดับฐานข้อมูล ช่วยเร่งความเร็วให้กระบวนการทำงานของคุณ
- **เขียนโค้ด SQL ที่สะอาดขึ้น** อ่านง่าย และมีประสิทธิภาพมากขึ้นอย่างเหลือเชื่อ
- **ได้คำตอบที่ซับซ้อน** ด้วยคำสั่งเดียวที่ทรงพลัง

ตรรกะแบบมีเงื่อนไขช่วยให้คุณสามารถนำข้อมูลเชิงธุรกิจมาใส่ในแบบสอบถามได้โดยตรง แทนที่จะคำนวณตัวชี้วัดในภายหลัง คุณสามารถสร้างตัวชี้วัดเหล่านั้นได้ในขณะที่ดึงข้อมูลออกมา ซึ่งจะทำให้การวิเคราะห์ของคุณเร็วขึ้น ทำซ้ำได้ง่ายขึ้น และบูรณาการเข้ากับกระบวนการตัดสินใจได้ดียิ่งขึ้น

เมื่ออ่านคู่มือนี้จบ คุณจะสามารถเปลี่ยนข้อมูลให้เป็นการตัดสินใจ และใช้ประโยชน์จากฐานข้อมูลของคุณได้อย่างเต็มประสิทธิภาพ แพลตฟอร์มอย่าง ELECTE ซึ่งเป็นแพลตฟอร์มวิเคราะห์ข้อมูลที่ขับเคลื่อนด้วย AI สำหรับ SME ใช้หลักการเหล่านี้ในการสร้างรายงานโดยอัตโนมัติ เปลี่ยนคำสั่งค้นหาที่ซับซ้อนให้เป็นภาพที่เข้าใจง่ายทันที ซึ่งช่วยในการตัดสินใจทางธุรกิจ

หากตรรกะของคุณซับซ้อนกว่าแค่ "ถ้าเกิดสิ่งนี้ ให้ทำสิ่งนั้น" นิพจน์ **CASE** จะกลายเป็นเครื่องมือที่ทรงพลังและเชื่อถือได้ที่สุดของคุณใน SQL นี่ไม่ใช่เทคนิคเฉพาะของไดอะเล็กต์ใดไดอะเล็กต์หนึ่ง แต่เป็นมาตรฐาน ANSI-SQL สำหรับการจัดการเงื่อนไขหลายรายการ นั่นหมายความว่าโค้ดของคุณจะทำงานได้แทบทุกที่ ตั้งแต่ PostgreSQL ไปจนถึง SQL Server

ลองนึกภาพ `CASE` เป็นแผนผังการตัดสินใจที่ฝังอยู่ในคิวรีของคุณโดยตรง แทนที่จะซ้อน `IF` ที่ซับซ้อนเข้าไปในกันและกัน ซึ่งทำให้โค้ดอ่านยากอย่างรวดเร็วและกลายเป็นฝันร้ายในการดูแลรักษา `CASE` ช่วยให้คุณลำดับเงื่อนไขต่าง ๆ ได้อย่างเป็นระเบียบและต่อเนื่อง

### กรณีแบบง่ายเทียบกับกรณีแบบค้นหา

นิพจน์ `CASE` มีสองรูปแบบ แต่ละแบบออกแบบมาสำหรับสถานการณ์เฉพาะ

- **Simple CASE:** เหมาะอย่างยิ่งเมื่อคุณต้องการเปรียบเทียบความเท่ากันโดยตรงกับคอลัมน์เดียว ไวยากรณ์กระชับและสะอาด เหมาะสำหรับการแมปค่าที่แน่นอน เช่น การแปลงรหัสสถานะที่เป็นตัวเลข (1, 2, 3) ให้เป็นป้ายข้อความ ("ใช้งานอยู่", "ไม่ใช้งาน", "ถูกระงับ")
- **Searched CASE:** ที่นี่คุณมีความยืดหยุ่นสูงสุด แต่ละเงื่อนไข `WHEN` เป็นนิพจน์บูลีนที่แยกจากกัน คุณสามารถใช้หลายคอลัมน์ ตัวดำเนินการทางตรรกะอย่าง `AND` และ `OR` และการเปรียบเทียบที่ซับซ้อน (`>`, `<`, `<>`) นี่คือรูปแบบที่แท้จริงของตรรกะ **if-else if ใน SQL**

ในทางปฏิบัติ `Searched CASE` คือสิ่งที่คุณจะใช้ 90% ของเวลา มันคือเครื่องมือที่ช่วยให้คุณแปลงกฎทางธุรกิจที่ซับซ้อน – เช่น การแบ่งกลุ่มลูกค้าตามยอดใช้จ่าย _และ_ ความถี่ในการซื้อ – ให้อยู่ในคิวรีของคุณโดยตรง

### ตัวอย่างการใช้งานจริงในภาษา SQL หลักๆ

มาดูกันว่าจะใช้ `Searched CASE` สำหรับงานคลาสสิกอย่างไร นั่นคือการจัดหมวดหมู่สินค้าตามราคา คุณจะสังเกตเห็นว่าไวยากรณ์แทบจะเหมือนกันในไดอะเล็กต์หลัก ๆ ซึ่งเป็นข้อพิสูจน์ถึงความสามารถในการพกพาที่น่าทึ่งของมัน

**ตัวอย่างใน MySQL/PostgreSQL/SQL Server:**

`SELECTnome_prodotto,prezzo,CASEWHEN prezzo > 1000 THEN 'Premium'WHEN prezzo > 100 AND prezzo <= 1000 THEN 'Fascia Media'ELSE 'Economico'END AS categoria_prezzoFROM Prodotti;`

โค้ดนี้ทำอะไร? มันวิเคราะห์ทุกแถวของตาราง `Prodotti` หาก `prezzo` เกิน 1000 จะกำหนดป้าย 'Premium' หากไม่เป็นเช่นนั้น จะไปยังเงื่อนไขถัดไป: ตรวจสอบว่าอยู่ระหว่าง 100 ถึง 1000 หรือไม่เพื่อกำหนด 'Fascia Media' หากทั้งสองเงื่อนไขไม่เป็นจริง คำสั่ง `ELSE` จะเข้ามาทำหน้าที่เป็นตัวสำรอง โดยกำหนด 'Economico'

การนำ `CASE` มาใช้เติบโตขึ้นอย่างมีนัยสำคัญในภาคไอทีของอิตาลี การวิเคราะห์ตลาดแสดงให้เห็นว่ามีการเพิ่มขึ้น **45%** ในการใช้คิวรีที่ซับซ้อนซึ่งใช้ `CASE` โดยกลุ่ม SME ระหว่างปี 2020 ถึง 2025 รายงานของ ASSINT ปี 2023 ยังเผยว่า **68%** ของนักพัฒนาชาวอิตาลีนิยม `CASE` เพราะช่วยลดข้อผิดพลาดลง **32%** เมื่อเทียบกับตรรกะทางเลือกที่ซับซ้อนกว่า แม้แต่ใน Electe แพลตฟอร์มวิเคราะห์ข้อมูลที่ขับเคลื่อนด้วย AI ของเรา โครงสร้างเหล่านี้ก็มีความสำคัญพื้นฐานในการทำให้รายงานเป็นอัตโนมัติ ช่วยลดเวลาในการประมวลผลลง 60% สำหรับลูกค้าของเรา

แต่การเรียนรู้ที่จะใช้ `CASE` ไม่ได้หยุดอยู่แค่ `SELECT` คุณสามารถนำมันไปใช้ในคำสั่งอย่าง `WHERE`, `ORDER BY` และแม้แต่ `GROUP BY` เพื่อสร้างตัวกรอง การเรียงลำดับ และการรวมข้อมูลแบบไดนามิก ทำให้คิวรีของคุณฉลาดและยืดหยุ่นยิ่งขึ้น หากคุณต้องการเจาะลึกยิ่งขึ้น ผมแนะนำให้สำรวจ[คู่มือฉบับละเอียดเกี่ยวกับ CASE WHEN ใน SQL](https://www.electe.net/post/case-when-sql)ของเรา

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

### การเปรียบเทียบไวยากรณ์ CASE ในภาษา SQL หลักๆ

คุณสมบัติMySQLSQL ServerPostgreSQLSearched CASE (`CASE WHEN ... END`)รองรับรองรับรองรับSimple CASE (`CASE col WHEN ... END`)รองรับรองรับรองรับฟังก์ชันไบนารีทางเลือก`IF(cond, vero, falso)IIF(cond, vero, falso)`ไม่มีให้ใช้ ใช้ `CASE` แทนการจัดการชนิดข้อมูลในสาขา `THEN`/`ELSE`ยืดหยุ่น แปลงชนิดข้อมูลอัตโนมัติเข้มงวด ต้องเป็นชนิดเดียวกันหรือแปลงได้โดยนัยเข้มงวด ต้องเป็นชนิดที่เข้ากันได้เท่านั้นเมื่อละเว้นคำสั่ง `ELSE`คืนค่า `NULL`คืนค่า `NULL`คืนค่า `NULL`

ทั้งสามฐานข้อมูล — **MySQL**, **SQL Server (T-SQL)** และ **PostgreSQL** — รองรับทั้ง Searched CASE และ Simple CASE ด้วยไวยากรณ์มาตรฐานเดียวกัน: `CASE WHEN ... END`

ในส่วนของ **ฟังก์ชันทางเลือก** MySQL มี `IF(cond, true, false)` และ SQL Server มี `IIF(cond, true, false)` ส่วน PostgreSQL ไม่มีฟังก์ชันที่เทียบเท่ากับ `IIF` โดยตรง และต้องใช้ `CASE` ในทุกสถานการณ์

ในด้าน**การจัดการชนิดข้อมูล** MySQL เป็นตัวที่ยืดหยุ่นที่สุดในสามตัวนี้ SQL Server เข้มงวดกว่า: ผลลัพธ์ทั้งหมดในสาขา `THEN` และ `ELSE` ต้องเป็นชนิดข้อมูลเดียวกันหรือแปลงกันได้โดยปริยาย PostgreSQL ก็เข้มงวดเช่นกัน และต้องการชนิดข้อมูลที่เข้ากันได้ระหว่างทุกสาขาของ `CASE`

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

## การเลือกใช้ IF และ IIF สำหรับเงื่อนไขไบนารีแบบง่าย

แน่นอนว่านิพจน์ `CASE` เป็นเหมือนมีดพกสวิสสำหรับจัดการตรรกะที่ซับซ้อน แต่จะเกิดอะไรขึ้นเมื่อทางแยกนั้นเรียบง่าย เป็นการเลือกแบบตรงไปตรงมาระหว่างสองตัวเลือก? สำหรับสถานการณ์ "if-else" ล้วนๆ แบบนี้ SQL บางไดอาเล็กต์มีทางเลือกที่ตรงและกระชับกว่าให้คุณ

ลองนึกภาพว่ามันเป็นทางลัด แทนที่จะสร้างบล็อก `CASE` ทั้งก้อนเพียงเพื่อจัดการผลลัพธ์สองอย่าง คุณสามารถใช้ฟังก์ชันเดียวที่ทำให้โค้ดกระชับขึ้น และพูดตรงๆ ว่าอ่านง่ายขึ้นในทันทีที่เห็น

### ฟังก์ชัน IF ใน MySQL

**MySQL** เสนอฟังก์ชัน `IF()` ซึ่งทำในสิ่งที่มันสัญญาไว้พอดี: รับสามอาร์กิวเมนต์และไม่ต้องการอะไรมากไปกว่านั้น

1. เงื่อนไขที่ต้องตรวจสอบ
2. ค่าที่จะคืนกลับหากเป็นจริง
3. ค่าที่จะคืนกลับหากเป็นเท็จ

ไวยากรณ์นั้นสะอาดมาก: `IF(condizione, valore_se_vero, valore_se_falso)`

มาดูตัวอย่างที่นำไปใช้ได้จริงกัน สมมติว่าคุณต้องการติดป้ายผู้ใช้บนแพลตฟอร์มของคุณอย่างรวดเร็วว่า 'Attivo' หรือ 'Inattivo' โดยอิงจากวันที่เข้าสู่ระบบครั้งล่าสุด ด้วย `IF` ก็เสร็จเรียบร้อย:

`SELECTnome_utente,IF(last_login > '2023-01-01', 'Attivo', 'Inattivo') AS stato_utenteFROM Utenti;`

ไม่ต้องสงสัยเลยว่ามันกระชับกว่า `CASE` ที่เทียบเท่ากัน อันที่จริง ข้อมูลในอุตสาหกรรมก็ชี้ชัดเจน: การใช้ `IF(condition, true, false)` เพิ่มขึ้น **52%** ในกลุ่มธุรกิจขนาดกลางของอิตาลีตั้งแต่ปี 2019

หากต้องการเจาะลึกมากขึ้น คุณสามารถดู[รายละเอียดเพิ่มเติมเกี่ยวกับนิพจน์เงื่อนไขใน SQL](https://support.workiva.com/hc/it/articles/360042533552-Espressioni-condizionali-SQL)

### ฟังก์ชัน IIF ใน SQL Server

**SQL Server** ก็ไม่น้อยหน้า โดยมีฟังก์ชันที่แทบจะเหมือนกัน: `IIF()` (ย่อมาจาก _Immediate IF_) การทำงานเหมือนกับ `IF()` ใน MySQL ตรรกะเดียวกัน ไวยากรณ์เดียวกัน

ดังนั้น กลับไปที่ตัวอย่างก่อนหน้านี้ สำหรับ SQL Server เราจะเขียนว่า:

`SELECTnome_utente,IIF(last_login > '2023-01-01', 'Attivo', 'Inattivo') AS stato_utenteFROM Utenti;`

อินโฟกราฟิกนี้ช่วยให้คุณมองเห็นกระบวนการตัดสินใจในการเลือกระหว่าง `Simple CASE` และ `Searched CASE` โดยอิงจากประเภทของการเปรียบเทียบที่คุณต้องทำ

แนวคิดหลักนั้นเรียบง่าย: หากคุณกำลังตรวจสอบค่าเดียวสำหรับความเท่ากัน `Simple CASE` จะสะอาดกว่า สำหรับตรรกะอื่นใด `Searched CASE` คือทางเลือกที่ถูกต้อง

**เมื่อไหร่ควรใช้ IF/IIF?** ใช้ได้เลยโดยไม่ต้องคิดมากสำหรับเงื่อนไขแบบสองทาง ชัดเจนและเรียบง่าย แต่ระวัง: ทันทีที่ตรรกะของคุณเริ่มต้องการ "elseif" ให้กลับไปใช้ `CASE` ทันที มันเป็นทางเลือกที่ดีที่สุดเสมอเพื่อรักษาให้โค้ดอ่านง่ายและบำรุงรักษาได้ในระยะยาว

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

## การนำตรรกะแบบมีเงื่อนไขไปใช้ในทางปฏิบัติ: ตัวอย่างในโลกแห่งความเป็นจริง

พลังที่แท้จริงของนิพจน์เงื่อนไขใน SQL จะปรากฏชัดเมื่อคุณนำไปใช้กับปัญหาทางธุรกิจที่เป็นรูปธรรม นี่คือจุดที่ทฤษฎีเปลี่ยนเป็นการลงมือทำ มาดูกันว่า `IF`, `ELSE` และโดยเฉพาะ `CASE WHEN` หยุดเป็นแค่คำสั่งธรรมดาและกลายเป็นเครื่องมือที่สามารถเปลี่ยนข้อมูลดิบให้เป็นข้อมูลเชิงลึกเชิงกลยุทธ์ได้อย่างไร โดยทำโดยตรงภายในฐานข้อมูล

เราจะวิเคราะห์สี่สถานการณ์ที่นักวิเคราะห์ข้อมูลหรือนักพัฒนาทุกคนต้องเจอไม่ช้าก็เร็ว ตั้งแต่การตลาดไปจนถึงการจัดการข้อมูล โดยแสดงให้เห็นว่า `CASE WHEN` ที่มีโครงสร้างดีสามารถทำให้งานที่ซับซ้อนเป็นอัตโนมัติและให้คำตอบได้ทันทีอย่างไร

### การแบ่งกลุ่มลูกค้าแบบไดนามิก

ลองนึกภาพว่าคุณต้องการแบ่งกลุ่มลูกค้าของคุณเพื่อเปิดตัวแคมเปญการตลาดที่มีประสิทธิภาพมากขึ้น วิธีการแบบดั้งเดิม? ส่งออกทุกอย่างไปยังสเปรดชีตแล้วเริ่มปรับแต่งสูตรและตัวกรอง แต่มีวิธีที่ฉลาดกว่ามาก: สร้างกลุ่มแบบไดนามิกโดยตรงในคิวรี `SELECT` ของคุณ

เทคนิคนี้ช่วยให้คุณติดแท็กให้กับลูกค้าแต่ละรายตามพฤติกรรมการซื้อ เช่น ยอดใช้จ่ายรวม หรือวันที่สั่งซื้อครั้งล่าสุด เป็นวิธีที่มีประสิทธิภาพในการระบุลูกค้าที่ดีที่สุด ลูกค้าประจำ และลูกค้าที่มีแนวโน้มที่จะเลิกใช้บริการได้อย่างรวดเร็ว

**ตัวอย่างที่นำไปใช้ได้จริง:**

`SELECTID_Cliente,Nome,Spesa_Totale,Ultimo_Acquisto,CASEWHEN Spesa_Totale > 5000 AND Ultimo_Acquisto >= '2023-10-01' THEN 'Cliente Premium'WHEN Spesa_Totale > 1000 THEN 'Cliente Fedele'WHEN Ultimo_Acquisto < '2023-01-01' THEN 'Cliente a Rischio'ELSE 'Cliente Occasionale'END AS Segmento_ClienteFROM Clienti;`

ด้วยคิวรีเดียว ข้อมูลของคุณจะได้รับบริบทที่สำคัญสำหรับกลยุทธ์การตลาดและการรักษาลูกค้าของคุณ นี่คือหนึ่งในเสาหลักสำหรับสร้าง[ตัวอย่างฐานข้อมูลเชิงสัมพันธ์](https://www.electe.net/post/esempio-di-database)ที่มีประโยชน์ต่อธุรกิจอย่างแท้จริง ไม่ใช่แค่คลังเก็บข้อมูล

### การทำความสะอาดและกำหนดมาตรฐานข้อมูล

คุณภาพของข้อมูลคือทุกสิ่ง หากไม่มีข้อมูลที่สะอาด การวิเคราะห์ทุกอย่างก็มีโอกาสผิดพลาด น่าเสียดายที่ข้อมูลที่ป้อนด้วยมือมักจะยุ่งเหยิง: ไม่สอดคล้องกัน เต็มไปด้วยข้อผิดพลาดในการพิมพ์ หรือมีรูปแบบที่แตกต่างกัน การใช้ตรรกะเงื่อนไขในคำสั่ง `UPDATE` ช่วยให้คุณทำความสะอาดและปรับมาตรฐานชุดข้อมูลทั้งหมดได้ด้วยคำสั่งเดียว

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

**ตัวอย่างการใช้งานจริง:**

`UPDATE IndirizziSETStato = CASEWHEN Stato IN ('NY', 'New York', 'new-york') THEN 'New York'WHEN Stato IN ('CA', 'California', 'cali') THEN 'California'ELSE Stato -- คงค่าเดิมไว้สำหรับรัฐอื่นๆENDWHEREPaese = 'USA';`

### การคำนวณโบนัสที่ซับซ้อน

การคำนวณค่าตอบแทนผันแปรมักเป็นเรื่องยุ่งยาก เพราะขึ้นอยู่กับปัจจัยมากมาย เช่น ผลการขาย อายุงาน และความสำเร็จของเป้าหมายทีม แทนที่จะจัดการกฎเกณฑ์ที่ซับซ้อนเหล่านี้ด้วยสคริปต์ภายนอก หรือที่แย่กว่านั้นคือ Excel คุณสามารถรวมกฎเหล่านั้นไว้ใน stored procedure ของ SQL ได้

นอกจากจะช่วยรวมศูนย์ตรรกะทางธุรกิจแล้ว ยังช่วยให้มั่นใจได้ว่าการคำนวณจะดำเนินการอย่างสม่ำเสมอและปลอดภัย ลดความเสี่ยงจากข้อผิดพลาดที่เกิดจากมนุษย์ และสร้างความโปร่งใส

สโตร์โพรซีเดอร์ (stored procedure) สามารถรับ ID ของพนักงานเป็นอินพุตและคืนค่าโบนัสที่แม่นยำ โดยใช้ตรรกะ `if else if` ที่ซับซ้อน ซึ่งอิงตามข้อมูลผลการปฏิบัติงานที่มีอยู่แล้วในฐานข้อมูล

**ตัวอย่างตรรกะ (ใน T-SQL):**

`CREATE PROCEDURE CalcolaBonusDipendente@ID_Dipendente INTASBEGINDECLARE @AnniServizio INT;DECLARE @VenditeAnnuali DECIMAL(10, 2);DECLARE @Bonus DECIMAL(10, 2);SELECT @AnniServizio = Anni_Servizio, @VenditeAnnuali = Vendite_2023FROM PerformanceDipendenti WHERE ID_Dipendente = @ID_Dipendente;IF @VenditeAnnuali > 100000SET @Bonus = @VenditeAnnuali * 0.10; -- โบนัส 10% สำหรับผู้ทำผลงานยอดเยี่ยมELSE IF @VenditeAnnuali > 50000 AND @AnniServizio > 5SET @Bonus = @VenditeAnnuali * 0.07; -- 7% สำหรับพนักงานอาวุโสที่มียอดขายดีELSESET @Bonus = @VenditeAnnuali * 0.05; -- โบนัสมาตรฐาน 5%-- ตรรกะสำหรับอัปเดตตารางหรือคืนค่าSELECT @Bonus AS Bonus_Calcolato;END;`

### การสร้างรายงานที่ยืดหยุ่น

สุดท้าย ตรรกะเงื่อนไขสามารถทำให้รายงานของคุณมีความยืดหยุ่นอย่างเหลือเชื่อ การใช้ `CASE` ภายในฟังก์ชันการรวมข้อมูลอย่าง `COUNT` หรือ `SUM` ช่วยให้คุณสร้างเมทริกซ์ที่ซับซ้อนได้ด้วยการสแกนตารางเพียงครั้งเดียว

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

**ตัวอย่างการใช้งานจริง:**

`SELECTCOUNT(CASE WHEN Stato = 'Spedito' THEN 1 END) AS Ordini_Spediti,COUNT(CASE WHEN Stato = 'In Attesa' THEN 1 END) AS Ordini_In_Attesa,SUM(CASE WHEN Regione = 'Nord' THEN Totale END) AS Vendite_Nord,SUM(CASE WHEN Regione = 'Sud' THEN Totale END) AS Vendite_SudFROM Ordini;`

## การจัดการค่า NULL และการเพิ่มประสิทธิภาพการทำงาน

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

ค่า NULL เป็นสิ่งแปลกประหลาดใน SQL การเปรียบเทียบโดยตรงกับ `NULL` ใดๆ (เช่น `colonna = NULL` หรือ `colonna <> NULL`) จะไม่คืนค่าทั้งจริงหรือเท็จ แต่เป็นสถานะที่สาม: `UNKNOWN` พฤติกรรมที่ดูเหมือนไม่มีอันตรายนี้สามารถสร้างหลุมดำที่แท้จริงในตรรกะ `if else if in sql` ของคุณ โดยตัดแถวที่คุณมั่นใจว่าจะรวมออกไป และทำให้ผลลัพธ์ของคุณผิดเพี้ยน

### จัดการค่า NULL อย่างเชิงรุก

เพื่อไม่ให้ตกหลุมพรางนี้ ทางออกมีเพียงหนึ่งเดียว: จัดการค่า NULL อย่างชัดเจนและเชิงป้องกันไว้ก่อน แทนที่จะไขว้นิ้วและหวังว่าข้อมูลจะสะอาด คุณสามารถใช้ฟังก์ชันเฉพาะโดยตรงภายในนิพจน์ `CASE` หรือ `IF` ของคุณ

อาวุธสองชิ้นที่มีประสิทธิภาพที่สุดในคลังของคุณคือ `COALESCE` และ `ISNULL`

- `COALESCE(colonna, valore_default)`: นี่คือฟังก์ชันมาตรฐาน ANSI-SQL ซึ่งหมายความว่าคุณจะพบมันได้แทบทุกที่ มันคืนค่าแรกที่ไม่ใช่ NULL ที่พบในรายการอาร์กิวเมนต์ เหมาะสำหรับการแทนที่ `NULL` ด้วยทางเลือกที่ปลอดภัยทันที เช่น ศูนย์หรือสตริง 'N/D' ก่อนที่ตรรกะเงื่อนไขของคุณจะเริ่มทำงาน
- `ISNULL(colonna, valore_default)`: เป็นลักษณะเฉพาะของภาษาถิ่นอย่าง [SQL Server](https://www.microsoft.com/it-it/sql-server) ทำสิ่งเดียวกันกับ `COALESCE` โดยพื้นฐานเมื่อคุณใช้อาร์กิวเมนต์เพียงสองตัว แต่ระวังไว้ เพราะมีความแตกต่างเล็กน้อยแต่สำคัญในวิธีที่มันจัดการกับประเภทข้อมูล

เมื่อรวมฟังก์ชันเหล่านี้เข้าด้วยกัน ตรรกะของคุณจะกลายเป็นแบบกันกระแทกต่อ `NULL` ได้ เรียบง่ายและมีประสิทธิภาพ

การเลือกฟังก์ชันที่เหมาะสมสำหรับการจัดการค่า NULL สามารถสร้างความแตกต่างในแง่ของความสามารถในการใช้งานข้ามแพลตฟอร์มและประสิทธิภาพของโค้ดได้

### การเปรียบเทียบฟังก์ชันการจัดการค่าว่าง (NULL)

_คู่มือฉบับย่อสำหรับการเลือกระหว่าง COALESCE, ISNULL และ NULLIF ตามภาษาถิ่น SQL และกรณีการใช้งานเฉพาะ พร้อมตัวอย่างการใช้งานจริง_

**COALESCE** คืนค่าแรกที่ไม่ใช่ NULL จากรายการอาร์กิวเมนต์ เป็นฟังก์ชันที่ยืดหยุ่นและอเนกประสงค์ที่สุด รองรับโดยภาษาถิ่นหลักทั้งหมด: SQL Server, PostgreSQL, Oracle, MySQL และ SQLite ตัวอย่างการใช้งานทั่วไปคือการคืนค่าอีเมลแรกที่มีอยู่ระหว่างอีเมลที่ทำงาน อีเมลส่วนตัว และค่าสำรอง: `SELECT COALESCE(email_lavoro, email_personale, 'Nessuna email') FROM utenti`

**ISNULL** แทนที่ค่า NULL ด้วยทางเลือกที่ระบุไว้ มีความยืดหยุ่นน้อยกว่า COALESCE เนื่องจากรับอาร์กิวเมนต์ได้เพียง 2 ตัวเท่านั้น และใช้งานได้เฉพาะใน SQL Server และ T-SQL เท่านั้น ตัวอย่างการใช้งานจริงคือการคืนค่าราคาป้ายเมื่อไม่มีราคาส่วนลด: `SELECT ISNULL(prezzo_scontato, prezzo_listino) FROM prodotti`

**NULLIF** คืนค่า NULL หากนิพจน์สองตัวมีค่าเท่ากัน มิฉะนั้นจะคืนค่าตัวแรก มีประโยชน์อย่างยิ่งในการหลีกเลี่ยงการหารด้วยศูนย์ และรองรับโดย SQL Server, PostgreSQL, Oracle และ MySQL ตัวอย่างที่เป็นตัวแทนคือการคำนวณค่าเฉลี่ยต่อคำสั่งซื้อโดยป้องกันการหารด้วยศูนย์: `SELECT vendite_totali / NULLIF(numero_ordini, 0) AS media_ordine FROM report`

สรุปแล้ว `COALESCE` เกือบจะเป็นตัวเลือกที่ปลอดภัยและพกพาได้ดีที่สุดเสมอ ใช้ `ISNULL` หากคุณทำงานเฉพาะบน SQL Server และชอบไวยากรณ์ของมัน และเก็บ `NULLIF` ไว้ใช้สำหรับกรณีเฉพาะ เช่น การป้องกันข้อผิดพลาดทางคณิตศาสตร์

### ปรับปรุงประสิทธิภาพของการค้นหาแบบมีเงื่อนไข

ตรรกะเงื่อนไข โดยเฉพาะอย่างยิ่งเมื่อฝังอยู่ในคำสั่ง `WHERE` อาจกลายเป็นตัวถ่วงตัวจริงสำหรับควีรีของคุณ เพราะบางครั้งมันขัดขวางไม่ให้ฐานข้อมูลใช้ดัชนีที่มีอยู่ บังคับให้ต้องสแกนทั้งตารางและทำให้ทุกอย่างช้าลง

ควีรีจะยังไม่ "เสร็จสมบูรณ์" จนกว่าจะเร็ว การปรับแต่งเงื่อนไข `CASE` ไม่ใช่ขั้นตอนที่ทำหรือไม่ทำก็ได้ แต่เป็นส่วนสำคัญของการเขียนโค้ด SQL ระดับมืออาชีพที่ไม่ทำให้ระบบทำงานหนักเกินไป

ต่อไปนี้เป็นเคล็ดลับที่เป็นประโยชน์บางประการเพื่อให้แน่ใจว่าคำถามของคุณไม่เพียงแต่ถูกต้อง แต่ยังกระชับอีกด้วย:

1. **เรียงลำดับเงื่อนไข **`WHEN`** ตามความน่าจะเป็น**: ให้วางเงื่อนไขที่เกิดขึ้นบ่อยที่สุดไว้ก่อนเสมอ เอนจินของฐานข้อมูลจะหยุดที่เงื่อนไขแรกที่เป็นจริง เทคนิคเล็กๆ นี้สามารถลดปริมาณงานที่ต้องทำได้อย่างมาก โดยเฉพาะกับตารางขนาดใหญ่มาก
2. **ทำให้นิพจน์เรียบง่าย**: พยายามหลีกเลี่ยงฟังก์ชันที่ซับซ้อนหรือ subquery ภายในคำสั่ง `WHEN` แต่ละแถวต้องถูกประเมิน ยิ่งเงื่อนไขซับซ้อนมากเท่าไร ก็ยิ่งใช้เวลามากขึ้นเท่านั้น ความเรียบง่ายให้ผลตอบแทนเสมอในแง่ของประสิทธิภาพ
3. **ระวังคำสั่ง **`WHERE`: นี่คือกฎทองข้อหนึ่ง การใช้ฟังก์ชันกับคอลัมน์ที่มีดัชนีในคำสั่ง `WHERE` (เช่น `WHERE YEAR(data_ordine) = 2023`) เป็นหนึ่งในวิธีที่พบบ่อยที่สุดในการ "ทำลาย" ดัชนี ทางที่ดีกว่ามากคือรักษาคอลัมน์ให้ "สะอาด" และใช้การแปลงค่าที่ด้านขวาของการเปรียบเทียบแทน หากเป็นไปได้ (`WHERE data_ordine >= '2023-01-01' AND data_ordine < '2024-01-01'`)

## จากคำพูดสู่การกระทำ: บทเรียนสำคัญสำหรับตรรกะ SQL

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

- **เลือกใช้ **`CASE`** เสมอเพื่อความสามารถในการพกพา** เนื่องจากเป็นมาตรฐาน ANSI-SQL จึงเป็นภาษากลางของฐานข้อมูล หากตรรกะของคุณมีผลลัพธ์ที่เป็นไปได้มากกว่าสองแบบ `CASE` ไม่ใช่ทางเลือก แต่เป็นตัวเลือกที่ทำให้โค้ดของคุณแข็งแกร่งและไม่ขึ้นกับแพลตฟอร์ม นับเป็นการลงทุนเพื่ออนาคต
- **เลือกใช้ **`IF`**/**`IIF`** เฉพาะเพื่อความเรียบง่าย (และหากทำได้)** ฟังก์ชันเหล่านี้ยอดเยี่ยมด้วยไวยากรณ์ที่กระชับสำหรับเงื่อนไขแบบไบนารี (จริง/เท็จ) แต่ทันทีที่ตรรกะซับซ้อนขึ้นและคุณต้องการ "หรือถ้า..." เพิ่มเติม ให้เลิกใช้ทันทีและกลับไปใช้ความชัดเจนและความสามารถในการขยายของ `CASE`
- **เตรียมรับมือกับ **`NULL` เสมอ ค่า `NULL` ที่ไม่ได้รับการจัดการอาจทำให้ผลลัพธ์ของคุณผิดเพี้ยนได้ ควรจัดการอย่างชัดเจนด้วย `COALESCE` หรือการตรวจสอบ `IS NULL` เสมอ เปรียบเสมือนการคาดเข็มขัดนิรภัย บางทีอาจไม่จำเป็นเสมอไป แต่เมื่อจำเป็นขึ้นมา มันจะช่วยชีวิตคุณได้
- **ใส่ **`ELSE`** เสมอ** การละเว้นคำสั่ง `ELSE` ใน `CASE` ก็เหมือนกับการเปิดประตูทิ้งไว้ให้เกิดผลลัพธ์ที่ไม่คาดคิด (จะคืนค่า `NULL`) การเพิ่ม `ELSE` ทำให้พฤติกรรมของควีรีของคุณคาดเดาได้ และปกป้องคุณจากเรื่องเซอร์ไพรส์ที่ไม่ดี
- **ปรับลำดับเงื่อนไขให้เหมาะสม** ให้วางเงื่อนไขที่มีความน่าจะเป็นสูงสุดไว้ที่จุดเริ่มต้นของบล็อก `CASE` เสมอ เอนจิน SQL จะหยุดที่เงื่อนไขแรกที่เป็นจริง สำหรับตารางที่มีข้อมูลหลายล้านแถว เทคนิคเล็กๆ นี้สามารถเร่งความเร็วควีรีของคุณได้อย่างมีนัยสำคัญ

เมื่อนำหลักการเหล่านี้ไปใช้อย่างสม่ำเสมอ คุณจะไม่ได้เป็นเพียงคนเขียนควีรีอีกต่อไป แต่กำลังออกแบบ[โซลูชันบิสซิเนสอินเทลลิเจนซ์](https://www.electe.net/post/software-business-intelligence)ที่แข็งแกร่ง สามารถทนทานต่อการทดสอบของกาลเวลาและข้อมูลที่ไม่สมบูรณ์แบบได้

## สรุป: เปลี่ยนข้อมูลของคุณให้เป็นการตัดสินใจ

คุณได้เห็นแล้วว่า แม้จะไม่มีคำสั่ง `IF ELSE IF` โดยตรง แต่ SQL ก็มีเครื่องมือที่ทรงพลังและยืดหยุ่นกว่านั้นให้ใช้ นิพจน์ `CASE WHEN` คือทรัพยากรหลักของคุณ เป็นมาตรฐานสากลที่ช่วยให้คุณสามารถนำตรรกะทางธุรกิจที่ซับซ้อนไปใช้ได้โดยตรงในควีรี สำหรับกรณีที่ง่ายกว่า ฟังก์ชันอย่าง `IF` และ `IIF` มีไวยากรณ์ที่กระชับกว่า

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

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

พร้อมที่จะเปลี่ยนข้อมูลของคุณให้เป็นความได้เปรียบทางการแข่งขันโดยไม่ต้องเขียนโค้ดสักบรรทัดหรือยัง? [มาดูกันว่า Electe ช่วยทำให้ข้อมูลของคุณมีความหมายได้อย่างไรด้วยเดโมฟรี](https://www.electe.net)