JOIN: รวมข้อมูลจากหลาย Table

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

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

ความจำเป็นของ JOIN

ลองจินตนาการว่าเรามีสอง Table:

customers: เก็บข้อมูลลูกค้า (customer_id, name, email)
orders: เก็บข้อมูลการสั่งซื้อ (order_id, customer_id, order_date, total_amount)

สังเกตว่า Table orders มี column customer_id ซึ่งอ้างอิงไปยัง Table customers นี่คือความสัมพันธ์แบบ "หนึ่งต่อหลาย" (one-to-many): ลูกค้าหนึ่งคนสามารถมีคำสั่งซื้อได้หลายรายการ

หากเราต้องการทราบว่าลูกค้าชื่อ "Alice" สั่งซื้ออะไรบ้าง เราจะต้อง:

ค้นหา customer_id ของ "Alice" จาก Table customers
ใช้ customer_id ที่ได้ ไปค้นหาคำสั่งซื้อทั้งหมดที่เกี่ยวข้องจาก Table orders

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

ประเภทของ JOIN

PostgreSQL สนับสนุน JOIN หลายประเภท แต่ละประเภทมีลักษณะการทำงานที่แตกต่างกัน เราจะมาดู JOIN ที่สำคัญที่สุด:

INNER JOIN

INNER JOIN จะคืนค่าแถวที่ตรงกัน (match) ในทั้งสอง Table ตามเงื่อนไขที่กำหนด หากไม่มีแถวที่ตรงกันใน Table ใด Table หนึ่ง แถวนั้นจะไม่ถูกรวมอยู่ในผลลัพธ์

SELECT
  customers.name,
  orders.order_id,
  orders.order_date
FROM
  customers
INNER JOIN
  orders ON customers.customer_id = orders.customer_id
WHERE
  customers.name = 'Alice';

คำสั่งนี้จะเลือกชื่อลูกค้า (customers.name), รหัสคำสั่งซื้อ (orders.order_id) และวันที่สั่งซื้อ (orders.order_date) โดยจะรวมข้อมูลจาก Table customers และ orders โดยใช้เงื่อนไข customers.customer_id = orders.customer_id (คือ customer_id ในทั้งสอง Table ต้องตรงกัน) และกรองผลลัพธ์ให้แสดงเฉพาะคำสั่งซื้อของลูกค้าที่ชื่อ "Alice"

เหตุผลเชิงออกแบบ: INNER JOIN เป็น JOIN ที่ใช้บ่อยที่สุด เพราะมักจะให้ผลลัพธ์ที่ตรงกับความต้องการมากที่สุด คือการดึงข้อมูลที่เกี่ยวข้องจากทั้งสอง Table เท่านั้น

LEFT JOIN (หรือ LEFT OUTER JOIN)

LEFT JOIN จะคืนค่าแถวทั้งหมดจาก Table ทางซ้าย (ในตัวอย่างนี้คือ customers) และเฉพาะแถวที่ตรงกันจาก Table ทางขวา (orders) หากไม่มีแถวที่ตรงกันใน Table ทางขวา ระบบจะใส่ค่า NULL ใน column ของ Table ทางขวา

SELECT
  customers.name,
  orders.order_id,
  orders.order_date
FROM
  customers
LEFT JOIN
  orders ON customers.customer_id = orders.customer_id;

คำสั่งนี้จะแสดงข้อมูลลูกค้าทั้งหมด และหากลูกค้ามีคำสั่งซื้อ ก็จะแสดงข้อมูลคำสั่งซื้อด้วย หากลูกค้าไม่มีคำสั่งซื้อ column order_id และ order_date จะมีค่า NULL

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

RIGHT JOIN (หรือ RIGHT OUTER JOIN)

RIGHT JOIN ทำงานคล้ายกับ LEFT JOIN แต่จะสลับ Table ทางซ้ายและทางขวา กล่าวคือ จะคืนค่าแถวทั้งหมดจาก Table ทางขวา (orders) และเฉพาะแถวที่ตรงกันจาก Table ทางซ้าย (customers) หากไม่มีแถวที่ตรงกันใน Table ทางซ้าย ระบบจะใส่ค่า NULL ใน column ของ Table ทางซ้าย

SELECT
  customers.name,
  orders.order_id,
  orders.order_date
FROM
  customers
RIGHT JOIN
  orders ON customers.customer_id = orders.customer_id;

คำสั่งนี้จะแสดงข้อมูลคำสั่งซื้อทั้งหมด และหากคำสั่งซื้อนั้นมีลูกค้าที่เกี่ยวข้อง ก็จะแสดงข้อมูลลูกค้าด้วย หากคำสั่งซื้อไม่มีลูกค้าที่เกี่ยวข้อง (ซึ่งไม่ควรเกิดขึ้นในสถานการณ์ปกติ) column name จะมีค่า NULL

เหตุผลเชิงออกแบบ: RIGHT JOIN มักจะไม่ค่อยได้ใช้บ่อยเท่า LEFT JOIN เพราะสามารถเขียนใหม่ให้ใช้ LEFT JOIN ได้ โดยการสลับ Table ทางซ้ายและขวา อย่างไรก็ตาม บางครั้ง RIGHT JOIN อาจจะอ่านง่ายกว่าในบางสถานการณ์

FULL OUTER JOIN

FULL OUTER JOIN จะคืนค่าแถวทั้งหมดจากทั้งสอง Table หากมีแถวที่ตรงกันในทั้งสอง Table แถวเหล่านั้นจะถูกรวมเข้าด้วยกัน หากไม่มีแถวที่ตรงกันใน Table ใด Table หนึ่ง ระบบจะใส่ค่า NULL ใน column ของ Table นั้น

SELECT
  customers.name,
  orders.order_id,
  orders.order_date
FROM
  customers
FULL OUTER JOIN
  orders ON customers.customer_id = orders.customer_id;

คำสั่งนี้จะแสดงข้อมูลลูกค้าทั้งหมด และข้อมูลคำสั่งซื้อทั้งหมด โดยจะรวมข้อมูลที่เกี่ยวข้องเข้าด้วยกัน หากลูกค้าไม่มีคำสั่งซื้อ หรือคำสั่งซื้อไม่มีลูกค้าที่เกี่ยวข้อง ระบบจะใส่ค่า NULL ใน column ที่เกี่ยวข้อง

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

การกำหนดเงื่อนไข JOIN

เงื่อนไข JOIN (ON clause) เป็นส่วนสำคัญของการใช้ JOIN เพราะเป็นตัวกำหนดว่าแถวใดจาก Table หนึ่งจะถูกรวมกับแถวใดจาก Table อื่น เงื่อนไข JOIN ที่พบบ่อยที่สุดคือการเปรียบเทียบ column ที่เป็น Foreign Key กับ Primary Key ของ Table ที่เกี่ยวข้อง (เช่น customers.customer_id = orders.customer_id)

อย่างไรก็ตาม เงื่อนไข JOIN สามารถซับซ้อนกว่านั้นได้ ตัวอย่างเช่น เราสามารถใช้เงื่อนไข JOIN ที่อิงตามช่วงวันที่:

SELECT
  employees.name,
  salaries.salary,
  salaries.start_date,
  salaries.end_date
FROM
  employees
INNER JOIN
  salaries ON employees.employee_id = salaries.employee_id
WHERE
  CURRENT_DATE BETWEEN salaries.start_date AND salaries.end_date;

คำสั่งนี้จะเลือกชื่อพนักงาน (employees.name), เงินเดือน (salaries.salary), วันที่เริ่มต้นเงินเดือน (salaries.start_date) และวันที่สิ้นสุดเงินเดือน (salaries.end_date) โดยจะรวมข้อมูลจาก Table employees และ salaries โดยใช้เงื่อนไข employees.employee_id = salaries.employee_id และกรองผลลัพธ์ให้แสดงเฉพาะเงินเดือนที่ยัง Active อยู่ (คือวันที่ปัจจุบันอยู่ระหว่าง start_date และ end_date)

แนวปฏิบัติที่ดีในการใช้ JOIN

ใช้ Alias: การใช้ Alias (ชื่อแทน) สำหรับ Table ทำให้คำสั่ง SQL อ่านง่ายขึ้น ตัวอย่างเช่น:
```
SELECT
  c.name,
  o.order_id
FROM
  customers AS c
INNER JOIN
  orders AS o ON c.customer_id = o.customer_id;
  
```
ระบุ Column อย่างชัดเจน: เมื่อ column ที่มีชื่อเดียวกันปรากฏในหลาย Table ให้ระบุชื่อ Table อย่างชัดเจน เพื่อหลีกเลี่ยงความสับสน (เช่น customers.name แทนที่จะเป็น name)
ระมัดระวังเรื่อง Performance: การใช้ JOIN ที่ไม่ถูกต้องอาจทำให้ query ช้าลง ตรวจสอบให้แน่ใจว่าเงื่อนไข JOIN ของคุณมีประสิทธิภาพ และใช้ Index อย่างเหมาะสม

สรุป

JOIN เป็นเครื่องมือที่ทรงพลังในการรวมข้อมูลจากหลาย Table ใน PostgreSQL การเข้าใจ JOIN ประเภทต่างๆ และวิธีการกำหนดเงื่อนไข JOIN ที่ถูกต้อง จะช่วยให้คุณสามารถดึงข้อมูลที่ซับซ้อนและมีความหมายจากฐานข้อมูลของคุณได้อย่างมีประสิทธิภาพ ในบทถัดไป เราจะสำรวจหัวข้อที่ซับซ้อนขึ้น เช่น Subquery และ Common Table Expressions (CTEs) เพื่อให้คุณสามารถเขียน query ที่ซับซ้อนยิ่งขึ้นได้