Bagaimanakah lajur array berfungsi dalam PostgreSQL?

Question

Accepted Answer

PostgreSQL menyokong lajur **array** — satu lajur boleh menyimpan *berbilang nilai* daripada jenis yang sama. Ini ialah ciri Postgres yang tersendiri, berguna untuk menyimpan senarai (tag, peranan, skor) tanpa jadual berasingan, dengan operator dan fungsi untuk menanya.

## Mentakrif dan menyisip array

```sql
CREATE TABLE posts (
  id SERIAL PRIMARY KEY,
  title TEXT,
  tags TEXT[]                         -- an array of text
);

INSERT INTO posts (title, tags) VALUES
  ('Hello', ARRAY['ruby', 'web']),    -- ARRAY[] syntax
  ('World', '{"news", "tech"}');       -- or curly-brace literal
```

Sintaks `type[]` mengisytiharkan lajur array. Anda menyisip dengan sintaks literal `ARRAY[...]` atau `'{...}'`.

## Menanya array

```sql
-- ANY — does the array contain a value?
SELECT * FROM posts WHERE 'ruby' = ANY(tags);

-- @> containment — does the array contain ALL of these?
SELECT * FROM posts WHERE tags @> ARRAY['ruby', 'web'];

-- && overlap — do the arrays share ANY element?
SELECT * FROM posts WHERE tags && ARRAY['tech', 'news'];

-- access by index (1-based!) and length
SELECT tags[1], array_length(tags, 1) FROM posts;

-- unnest — expand an array into rows
SELECT id, unnest(tags) AS tag FROM posts;   -- one row per tag
```

Operator seperti `ANY` (mengandungi nilai), `@>` (containment), dan `&&` (overlap), serta fungsi seperti `unnest` (kembangkan kepada baris) dan `array_agg` (kumpulkan baris menjadi array), menjadikan array boleh ditanya.

## Mengindeks array (GIN)

```sql
-- a GIN index makes array containment/membership queries fast
CREATE INDEX idx_posts_tags ON posts USING GIN (tags);
-- now WHERE tags @> ARRAY['ruby'] uses the index
```

## Bila menggunakan array (dan bila tidak)

```text
✓ USE for: simple lists tightly coupled to the row (tags, roles, a few scores)
  where you don't need to query/join the individual values much
✗ AVOID when: you need to query, join, or maintain the values relationally,
  or the list is large/complex → a separate related table (normalized) is better
→ Arrays are convenient but can violate normalization; use them judiciously.
```

## Mengapa ia penting

Lajur array ialah ciri PostgreSQL yang tersendiri dan berguna, dan memahaminya bernilai untuk memanfaatkan keupayaan Postgres dan untuk membuat keputusan reka bentuk yang baik.

Array membolehkan anda menyimpan **berbilang nilai dalam satu lajur** (tag, peranan, senarai) tanpa jadual berasingan — mudah untuk senarai ringkas yang berkait rapat dengan satu baris.

Memahami cara mentakrif, menyisip, dan terutamanya **menanya** array (operator seperti `ANY` untuk keahlian, `@>` untuk containment, `&&` untuk overlap, dan fungsi seperti `unnest` untuk mengembangkan array menjadi baris) adalah perlu untuk menggunakannya dengan berkesan, dan mengetahui bahawa **indeks GIN** menjadikan pertanyaan array cekap adalah penting untuk prestasi.

Sama pentingnya ialah **pertimbangan reka bentuk** tentang bila menggunakan array berbanding jadual berkaitan yang ternormal: array mudah untuk senarai ringkas yang anda tidak perlu tanya, gabung, atau selenggara secara hubungan, tetapi ia boleh melanggar prinsip normalisasi dan menjadi janggal apabila anda perlu menanya nilai individu, menggabungkannya, atau menguruskan senarai kompleks/besar — dalam hal itu jadual berkaitan berasingan ialah pilihan ternormal yang lebih baik.

Memahami pertukaran (trade-off) ini (array untuk kemudahan dengan senarai berkait ringkas, jadual berasingan untuk data yang diuruskan secara hubungan) mencerminkan pertimbangan reka bentuk yang baik.

Memandangkan array ialah ciri Postgres yang berguna dan tersendiri yang boleh memudahkan reka bentuk tertentu (mengelakkan jadual gabung untuk senarai ringkas) tetapi boleh disalahgunakan (menyahnormalkan data yang sepatutnya hubungan), memahami lajur array — cara mentakrif, menanya, dan mengindeksnya, dan yang penting bila ia sesuai berbanding bila jadual ternormal lebih baik — ialah pengetahuan bernilai dan relevan secara praktikal untuk mereka bentuk skema Postgres yang menggunakan pendekatan yang betul untuk setiap jenis data berbilang nilai.