0Pricing
SQL Academy · บทเรียน

UNNEST และการรวมค่า

เปลี่ยนอาร์เรย์เป็นแถวและเปลี่ยนกลับ

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

UNNEST คืออะไร

PostgreSQL ช่วยให้คุณจัดเก็บอาร์เรย์ไว้ในคอลัมน์เดียวได้ แต่บางครั้งคุณจำเป็นต้องทำงานกับแต่ละองค์ประกอบแยกกัน ซึ่งเป็นจุดที่ UNNEST เข้ามาช่วย

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

ตัวอย่าง UNNEST พื้นฐาน

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

ในที่นี้ เราขยายอาร์เรย์จำนวนเต็มธรรมดาให้เป็นแถวแต่ละแถว:

SELECT UNNEST(ARRAY[10, 20, 30, 40]) AS value;

UNNEST กับอาร์เรย์ข้อความ

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

SELECT UNNEST(ARRAY['apple', 'banana', 'cherry']) AS fruit;

UNNEST จากคอลัมน์ในตาราง

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

ในตัวอย่างนี้ ตาราง products มีคอลัมน์อาร์เรย์ข้อความ tags:

CREATE TABLE products (
  id   SERIAL PRIMARY KEY,
  name TEXT,
  tags TEXT[]
);

INSERT INTO products (name, tags) VALUES
  ('Laptop',  ARRAY['electronics', 'computing', 'portable']),
  ('Shirt',   ARRAY['clothing', 'casual']),
  ('Blender', ARRAY['kitchen', 'electronics']);

SELECT name, UNNEST(tags) AS tag
FROM products;

การนับจำนวนแท็กที่ปรากฏ

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

รูปแบบคือใช้ UNNEST ในแบบสอบถามย่อยหรือ CTE จากนั้นใช้ GROUP BY กับค่าที่คลี่ออกมา:

SELECT tag, COUNT(*) AS product_count
FROM (
  SELECT UNNEST(tags) AS tag
  FROM products
) AS expanded
GROUP BY tag
ORDER BY product_count DESC;

UNNEST พร้อมลำดับตำแหน่ง

บางครั้งตำแหน่งขององค์ประกอบภายในอาร์เรย์มีความสำคัญ PostgreSQL มี WITH ORDINALITY สำหรับแนบหมายเลขแถวให้กับองค์ประกอบที่ขยายแต่ละรายการ เพื่อให้ทราบดัชนีเดิมในอาร์เรย์ (เริ่มนับจาก 1)

SELECT val, pos
FROM UNNEST(ARRAY['first', 'second', 'third']) WITH ORDINALITY AS t(val, pos);

การใช้ลำดับตำแหน่งกับตาราง

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

CREATE TABLE playlists (
  id     SERIAL PRIMARY KEY,
  title  TEXT,
  tracks TEXT[]
);

INSERT INTO playlists (title, tracks) VALUES
  ('Morning Mix', ARRAY['Song A', 'Song B', 'Song C']);

SELECT p.title, track, position
FROM playlists p,
     UNNEST(p.tracks) WITH ORDINALITY AS t(track, position)
ORDER BY p.id, position;

การกรองหลังใช้ UNNEST

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

SELECT DISTINCT name
FROM products,
     UNNEST(tags) AS tag
WHERE tag = 'electronics';

การรวมกลับเป็นอาร์เรย์

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

SELECT ARRAY_AGG(tag ORDER BY tag) AS sorted_tags
FROM (
  SELECT UNNEST(ARRAY['cherry', 'apple', 'banana']) AS tag
) AS t;

การกำจัดสมาชิกที่ซ้ำกันในอาร์เรย์

การใช้งานจริงอย่างหนึ่งของการแปลงอาร์เรย์ด้วย UNNEST แล้วรวมกลับ คือการลบสมาชิกที่ซ้ำกันออกจากอาร์เรย์ ให้ใช้ UNNEST กับอาร์เรย์ ใช้ DISTINCT จากนั้นรวบรวมกลับด้วย ARRAY_AGG:

SELECT ARRAY_AGG(DISTINCT tag ORDER BY tag) AS unique_tags
FROM UNNEST(ARRAY['sql', 'database', 'sql', 'postgresql', 'database']) AS tag;

การรวมคอลัมน์อาร์เรย์หลายคอลัมน์

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

SELECT key, value
FROM UNNEST(
  ARRAY['name',    'city',      'role'],
  ARRAY['Alice',   'Istanbul',  'DBA']
) AS t(key, value);

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

ทดสอบความเข้าใจเกี่ยวกับ UNNEST และการรวมอาร์เรย์ใน PostgreSQL

สรุปบทเรียน

ในบทเรียนนี้ คุณได้เรียนรู้วิธีแปลงอาร์เรย์เป็นแถวและแปลงกลับอีกครั้งโดยใช้ฟังก์ชันในตัวของ PostgreSQL:

  • UNNEST — ขยายอาร์เรย์ให้เป็นหนึ่งแถวต่อสมาชิกหนึ่งตัว ใช้ได้ทั้งกับค่าคงที่และคอลัมน์ของตาราง
  • WITH ORDINALITY — เพิ่มดัชนีบอกตำแหน่งให้สมาชิกแต่ละตัวที่แยกออกมา เพื่อให้ทราบลำดับเดิมในอาร์เรย์
  • การกรอง — หลังจากแยกสมาชิกออกมาแล้ว คุณสามารถใช้ WHERE ได้เช่นเดียวกับแถวทั่วไป
  • ARRAY_AGG — ทำงานย้อนกลับกับ UNNEST โดยรวบรวมแถวกลับเป็นอาร์เรย์ และเลือกใช้ ORDER BY หรือ DISTINCT ได้
  • UNNEST แบบขนาน — อาร์เรย์หลายชุดในส่วนคำสั่ง FROM จะถูกขยายเคียงข้างกันและจับคู่ตามตำแหน่ง

เมื่อเชี่ยวชาญรูปแบบการแยก ประมวลผล และรวมกลับนี้แล้ว คุณจะจัดการข้อมูลอาร์เรย์ได้ด้วยความสามารถอันเต็มเปี่ยมของ SQL

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

บทเรียน “UNNEST และการรวมค่า” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “UNNEST และการรวมค่า”

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

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

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

บทเรียน “UNNEST และการรวมค่า” ใช้เวลานานแค่ไหน

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

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

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

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

  1. พื้นฐานคอลัมน์อาร์เรย์
  2. การค้นหาภายในอาร์เรย์
  3. UNNEST และการรวมค่า
  4. อาร์เรย์เทียบกับตารางแบบทำให้เป็นมาตรฐาน
← กลับไปที่ SQL Academy