PostgreSQL-ல் array column கள் எவ்வாறு செயல்படுகின்றன?

Question

Accepted Answer

PostgreSQL ஆனது **array** column களை ஆதரிக்கிறது — ஒரு column வொன்றில் ஒரே வகையின் *பல மதிப்புகள்* இருக்கலாம். இது PostgreSQL-ற்கு தனிப்பட்ட அம்சம் ஆகும், இது ஒரு தனி table இல்லாமல் lists (tags, roles, scores) சேமிக்க உபயோகமாக உள்ளது, query செய்வதற்கான operators மற்றும் functions உடன்.

## Arrays வை வரையறுத்தல் மற்றும் செருகுதல்

```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
```

`type[]` syntax ஆனது ஒரு array column வை declare செய்கிறது. நீங்கள் `ARRAY[...]` அல்லது `'{...}'` literal syntax உடன் செருகுகிறீர்கள்.

## Arrays ஐ query செய்தல்

```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
```

`ANY` (மதிப்பு கொண்டு இருக்கிறதா), `@>` (containment), மற்றும் `&&` (overlap) போன்ற operators, மேலும் `unnest` (rows க்கு விரிவாக்க) மற்றும் `array_agg` (rows ஐ array ஆக aggregate செய்க) போன்ற functions, arrays ஐ query செய்ய முடியுமாக செய்கிறது.

## Arrays ஐ indexing செய்தல் (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
```

## Arrays ஐ எப்போது பயன்படுத்த வேண்டும் (மற்றும் எப்போது பயன்படுத்த கூடாது)

```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.
```

## இது ஏன் முக்கியமாக உள்ளது

Array columns ஆனது PostgreSQL-ற்கு ஒரு தனிப்பட்ட மற்றும் உபயோகமான அம்சம் ஆகும், மேலும் அவற்றைப் புரிந்துகொள்வது Postgres-ற்கு வசதிகளை leverage செய்வதற்கும் மற்றும் சரியான design முடிவுகளை செய்வதற்கும் மதிப்புடையதாக உள்ளது.

Arrays ஆனது **ஒரு column வில் பல மதிப்புகளை** (tags, roles, lists) சேமிக்க உங்களுக்கு அனுமதி கொடுக்கிறது ஒரு தனி table இல்லாமல் — எளிய lists க்கு편リ.

Arrays ஐ எவ்வாறு வரையறுக்க, செருக, மேலும் குறிப்பாக **query** செய்ய வேண்டும் என்பதை புரிந்துகொள்வது அவற்றை திறம்பட பயன்படுத்த தேவையாக உள்ளது (`ANY` membership க்கான, `@>` containment க்கான, `&&` overlap க்கான operators, மற்றும் arrays ஐ rows ஆக விரிவாக்க `unnest` போன்ற functions), மேலும் **GIN indexes** array queries ஐ செயல்பட்ச வாக செய்கிறது என்பதை அறிந்துகொள்வது performance க்கு முக்கியமாக உள்ளது.

समान रूप से முக்கியமாக உள்ளது arrays க்கு வேண்டும் வெர்சஸ normalized related table க்கு **design judgment**: arrays ஆனது எளிய lists க்கு편리ஸ் ஆகும் நீங்கள் query, join, அல்லது relationallyமாக பராமரிக்க வேண்டிய lists க்கு, ஆனால் அவை normalization principles ஐ மீறலாம் மற்றும் மாறிவிடலாம் awkward நீங்கள் individual values ஐ query செய்ய வேண்டும் போது, அவற்றை join செய்ய வேண்டும் போது, அல்லது ஒரு complex/large list ஐ பராமரிக்க வேண்டும் போது — இந்த விஷயங்களில் ஒரு தனி related table சிறந்த, normalized choice ஆக உள்ளது.

इस trade-off ஐ புரிந்துகொள்வது (arrays convenience க்கான எளிய coupled lists உடன், separate tables relationally-managed data க்கான) சரியான design judgment ஐ பிரதிபலிக்கிறது.

Since arrays ஆனது ஒரு உபயோகமான, தனிப்பட்ட Postgres feature ஆகும் இது certain designs ஐ simplify செய்ய முடியும் (ஒரு join table தவிர்க்க எளிய lists க்கு) ஆனால் misuse செய்ய முடியும் (data ஐ denormalize செய்தல் relational ஆக இருக்க வேண்டிய), array columns ஐ புரிந்துகொள்வது — அவற்றை எவ்வாறு வரையறுக்க, query, மற்றும் index செய்ய வேண்டும், மேலும் crucially எப்போது அவை suitable வெர்சஸ ஒரு normalized table சிறந்தமாக உள்ளது — ஆனது மதிப்புடையதாக, practically-relevant knowledge Postgres schemas design செய்வதற்கு multi-valued data வின் ஒவ்வொரு வகைக்கும் சரியான அணுகுமுறையை பயன்படுத்தி.