PostgreSQL में array columns कैसे काम करते हैं?

Question

Accepted Answer

PostgreSQL **array** columns का समर्थन करता है — एक एकल column समान type के *कई values* रख सकता है। यह एक विशिष्ट Postgres विशेषता है जो किसी अलग table के बिना lists (tags, roles, scores) संग्रहीत करने के लिए उपयोगी है, querying के लिए operators और functions के साथ।

## arrays को परिभाषित और insert करना

```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 घोषित करता है। आप `ARRAY[...]` या `'{...}'` literal syntax के साथ insert करते हैं।

## 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` (एक value समाहित करता है), `@>` (containment), और `&&` (overlap) जैसे operators, साथ ही `unnest` (rows में विस्तार) और `array_agg` (rows को एक array में एकत्रित करना) जैसे functions arrays को queryable बनाते हैं।

## arrays को index करना (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 की क्षमताओं का लाभ उठाने और ठोस डिज़ाइन निर्णय लेने दोनों के लिए मूल्यवान है।

Arrays आपको किसी अलग table के बिना एक **एकल column में कई values** (tags, roles, lists) संग्रहीत करने देते हैं — एक row से कसकर जुड़ी सरल lists के लिए सुविधाजनक।

यह समझना कि arrays को कैसे परिभाषित, insert और विशेष रूप से **query** करें (membership के लिए `ANY`, containment के लिए `@>`, overlap के लिए `&&` जैसे operators, और arrays को rows में विस्तारित करने के लिए `unnest` जैसे functions) उनका प्रभावी ढंग से उपयोग करने के लिए आवश्यक है, और यह जानना कि **GIN indexes** array queries को कुशल बनाते हैं, performance के लिए महत्वपूर्ण है।

समान रूप से महत्वपूर्ण है यह **डिज़ाइन निर्णय** कि arrays बनाम एक normalized related table का उपयोग कब करें: arrays उन सरल lists के लिए सुविधाजनक हैं जिन्हें आपको relationally query, join या maintain करने की ज़रूरत नहीं है, लेकिन वे normalization सिद्धांतों का उल्लंघन कर सकते हैं और तब असुविधाजनक बन जाते हैं जब आपको individual values को query करना, उन पर join करना, या एक complex/large list का प्रबंधन करना हो — जिस स्थिति में एक अलग related table बेहतर, normalized विकल्प है।

इस trade-off को समझना (सरल coupled lists के लिए सुविधा हेतु arrays, relationally-managed data के लिए अलग tables) ठोस डिज़ाइन निर्णय को दर्शाता है।

चूँकि arrays एक उपयोगी, विशिष्ट Postgres विशेषता हैं जो कुछ डिज़ाइनों को सरल बना सकती हैं (सरल lists के लिए एक join table से बचना) लेकिन गलत उपयोग की जा सकती हैं (ऐसे data को denormalizing करना जो relational होना चाहिए), array columns को समझना — उन्हें कैसे परिभाषित, query और index करें, और महत्वपूर्ण रूप से वे कब उपयुक्त हैं बनाम कब एक normalized table बेहतर है — Postgres schemas डिज़ाइन करने के लिए मूल्यवान, व्यावहारिक रूप से प्रासंगिक ज्ञान है जो प्रत्येक प्रकार के multi-valued data के लिए सही दृष्टिकोण का उपयोग करते हैं।