0Pricing
SQL Interview Prep · บทเรียน

ปรับโครงสร้างคิวรีซ้อนให้เป็น CTE

รูปแบบในการสัมภาษณ์จริง: เปลี่ยนคิวรีซ้อนที่อ่านไม่รู้เรื่องให้เป็น CTE แบบเป็นขั้นตอน

ปรับโครงสร้างคิวรีซ้อนให้เป็น CTE เป็นบทเรียน SQL Interview Prep ฟรีบน CoddyKit นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน SQL Interview Prep และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส SQL Interview Prep มีบทเรียนทั้งหมด 4 บทเรียน

การปรับโครงสร้างระหว่างการสัมภาษณ์จริง

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

บทเรียนนี้จะแนะนำขั้นตอนที่ต้องทำอย่างละเอียด เพื่อให้คุณทำได้อย่างใจเย็นบนกระดาน

เริ่มจากคำสั่งสอบถามชั้นในสุด

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

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

SELECT *
FROM (
    SELECT customer_id, SUM(amount) AS total
    FROM orders
    GROUP BY customer_id
) t
WHERE t.total > 1000;

ยกระดับหนึ่งชั้นให้เป็น CTE

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

การเปลี่ยนแปลงเพียงครั้งเดียวนี้ช่วยลดความซ้อนที่ผู้อ่านต้องทำความเข้าใจลงหนึ่งชั้น และตั้งชื่อที่สื่อความหมายให้ขั้นตอนนั้น

WITH spend AS (
    SELECT customer_id, SUM(amount) AS total
    FROM orders
    GROUP BY customer_id
)
SELECT *
FROM spend
WHERE total > 1000;

ตัวอย่างการซ้อนกันที่ซับซ้อนจริง

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

คำสั่งนี้ทำงานได้ถูกต้อง แต่ทำความเข้าใจได้ยาก เราจะค่อยๆ แยกออกเป็นขั้นตอน

SELECT AVG(o.amount) AS avg_order
FROM orders o
WHERE o.customer_id IN (
    SELECT customer_id
    FROM (
        SELECT customer_id, SUM(amount) AS total
        FROM orders
        GROUP BY customer_id
    ) s
    WHERE s.total > 1000
);

ตั้งชื่อขั้นตอนแรก

บล็อกที่อยู่ลึกที่สุดจะคำนวณยอดใช้จ่ายรวมต่อลูกค้า ยกบล็อกนี้เป็น CTE ชื่อ spend จากนั้นชั้นกลางก็เพียงกรองข้อมูลจาก CTE นี้

สังเกตว่าการแยกแต่ละส่วนช่วยลดความลึกของการซ้อนลงทีละหนึ่งระดับ และเพิ่มชื่อที่อธิบายตัวเองได้

WITH spend AS (
    SELECT customer_id, SUM(amount) AS total
    FROM orders
    GROUP BY customer_id
)
SELECT AVG(o.amount) AS avg_order
FROM orders o
WHERE o.customer_id IN (
    SELECT customer_id FROM spend WHERE total > 1000
);

ตั้งชื่อขั้นตอนที่สอง

แยกตัวกรองของ spend ออกมาเป็น CTE ของตัวเองชื่อ big_spenders จากนั้นคำสั่งสอบถามหลักที่เหลือจะกลายเป็นการเชื่อมตารางแบบแบน หรือการตรวจสอบการเป็นสมาชิกกับชุดข้อมูลที่มีชื่อชัดเจน

ตอนนี้แต่ละขั้นตอนมีหน้าที่เดียว ซึ่งเป็นลักษณะสำคัญของ SQL ที่สะอาดและเป็นระเบียบ

WITH spend AS (
    SELECT customer_id, SUM(amount) AS total
    FROM orders GROUP BY customer_id
),
big_spenders AS (
    SELECT customer_id FROM spend WHERE total > 1000
)
SELECT AVG(o.amount) AS avg_order
FROM orders o
JOIN big_spenders b ON b.customer_id = o.customer_id;

รักษาความหมายขณะปรับโครงสร้าง

กฎสำคัญที่สุดคือ การปรับโครงสร้างต้องไม่เปลี่ยนแปลงผลลัพธ์ โปรดระวังจุดที่อาจเปลี่ยนผลลัพธ์โดยไม่รู้ตัว

  • การเปลี่ยน IN เป็น JOIN อาจทำให้เกิดแถวซ้ำ หากข้อมูลฝั่งขวาไม่มีค่าที่ไม่ซ้ำกัน
  • NOT IN เมื่อมีค่าที่ไม่มีข้อมูลจะทำงานแตกต่างจาก NOT EXISTS
  • ระดับรายละเอียดของการรวมข้อมูลต้องคงเดิม

กล่าวถึงความเสี่ยงเหล่านี้ออกมา เพื่อแสดงให้เห็นว่าคุณใส่ใจในรายละเอียด

ตรวจสอบการปรับโครงสร้าง

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

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

SELECT COUNT(*), SUM(amount)
FROM orders
WHERE customer_id IN (SELECT customer_id FROM big_spenders);

เมื่อใดที่ NOT ควรปรับโครงสร้าง

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

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

รายการตรวจสอบการปรับโครงสร้าง

วิธีการที่ท่องจำและกล่าวตามได้:

  • อ่านจากด้านในออกด้านนอกเพื่อค้นหาซับคิวรีที่อยู่ลึกที่สุด
  • ยกซับคิวรีนั้นขึ้นมาเป็น CTE ที่มีชื่อ
  • ทำซ้ำโดยไล่ขึ้นด้านบนทีละชั้น
  • ตั้งชื่อแต่ละขั้นตามสิ่งที่ขั้นนั้นสร้างขึ้น
  • ยืนยันว่าผลลัพธ์ไม่เปลี่ยนแปลง (ระวังกับดักของ IN/JOIN และ NULL)

วิธีนี้เปลี่ยนคิวรีซ้อนที่ดูน่ากลัวให้กลายเป็นการเขียนใหม่อย่างเป็นขั้นตอนที่ทำได้อย่างใจเย็น

การสื่อสารเกี่ยวกับการปรับโครงสร้าง

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

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

ตรวจสอบความเข้าใจ

ระบุขั้นตอนแรกที่ถูกต้องเมื่อปรับโครงสร้างคิวรีที่ซ้อนกันลึกให้เป็น CTE

สรุป: การปรับโครงสร้างเป็น CTE

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

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

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

คำถามที่พบบ่อย

บทเรียน “ปรับโครงสร้างคิวรีซ้อนให้เป็น CTE” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “ปรับโครงสร้างคิวรีซ้อนให้เป็น CTE” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส SQL Interview Prep ให้อัปเกรดเป็น CoddyKit PRO คอร์ส SQL Interview Prep มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “ปรับโครงสร้างคิวรีซ้อนให้เป็น CTE”

รูปแบบในการสัมภาษณ์จริง: เปลี่ยนคิวรีซ้อนที่อ่านไม่รู้เรื่องให้เป็น CTE แบบเป็นขั้นตอน คุณปฏิบัติ SQL Interview Prep ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน SQL Interview Prep หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน SQL Interview Prep บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน

บทเรียน “ปรับโครงสร้างคิวรีซ้อนให้เป็น CTE” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน SQL Interview Prep นี้ได้ไหม

ได้ บทเรียน SQL Interview Prep ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

  1. เขียน CTE แรกของคุณ
  2. ต่อ CTE หลายรายการ
  3. CTE เทียบกับคิวรีย่อยเทียบกับตารางชั่วคราว
  4. ปรับโครงสร้างคิวรีซ้อนให้เป็น CTE
← กลับไปที่ SQL Interview Prep