PostgreSQL मध्ये array columns कसे काम करतात?

Question

Accepted Answer

PostgreSQL **array** columns साठी समर्थन प्रदान करते — एक एकल column एकाच type ची *अनेक values* ठेवू शकते. हे PostgreSQL चे विशिष्ट वैशिष्ट्य आहे जे lists (tags, roles, scores) संचयित करण्यासाठी उपयुक्त आहे, वेगळ्या table शिवाय, query करण्यासाठी 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 query-able बनवतात.

## 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 चे विशिष्ट आणि उपयुक्त वैशिष्ट्य आहेत, आणि त्यांची समज PostgreSQL च्या क्षमता वापरण्यासाठी आणि सुदृढ डिজाइन निर्णय घेण्यासाठी महत्वाचे आहे.

Arrays तुम्हाला **एकाच column मध्ये अनेक values** (tags, roles, lists) संचयित करण्यास देतात वेगळ्या table शिवाय — साध्या lists साठी सुविधाजनक जे row शी घनिष्ठपणे जोडलेले असतात.

Arrays कसे परिभाषित करायचे, insert करायचे, आणि विशेषतः **query** करायचे हे समजणे (membership साठी `ANY` सारखे operators, containment साठी `@>`, overlap साठी `&&`, आणि arrays rows मध्ये विस्तृत करण्यासाठी `unnest` सारखे functions) त्यांना प्रभावीपणे वापरण्यासाठी आवश्यक आहे, आणि **GIN indexes** array queries कार्यक्षम बनवतात हे जाणणे कार्यक्षमतेसाठी महत्वाचे आहे.

तितकेच महत्वाचे आहे arrays वापरायचे का विरुद्ध normalized related table: arrays साध्या lists साठी सुविधाजनक आहेत जे तुम्हाला query, join, किंवा relationally maintain करण्याची आवश्यकता नाही, परंतु ते normalization principles उल्लंघन करू शकतात आणि अव्यवस्थित होऊ शकतात जेव्हा तुम्हाला individual values query करणे आवश्यक असते, त्यांच्यावर join करणे, किंवा complex/large list manage करणे — अशा परिस्थितीत separate related table हा बेहतर, normalized पर्याय आहे.

हा trade-off समजणे (साध्या जोडलेल्या lists साठी arrays सोयीसाठी, relationally-managed data साठी वेगळे tables) सुदृढ डिजाइन निर्णय प्रतिबिंबित करते.

Arrays हे उपयुक्त, विशिष्ट Postgres वैशिष्ट्य असल्यामुळे जे काही डिजाइन सुलभ करू शकते (साध्या lists साठी join table टाळून) परंतु गैरवापर होऊ शकते (डेटा denormalize करून जे relational असावे), array columns समजणे — त्यांची परिभाषा कसे करायची, query कसे करायची, आणि index कसे करायची, आणि महत्वाचे म्हणजे ते कधी appropriate आहेत विरुद्ध कधी normalized table बेहतर आहे — Postgres schemas डिजाइन करण्यासाठी मूल्यवान, व्यावहारिकदृष्ट्या प्रासंगिक ज्ञान आहे जे multi-valued data च्या प्रत्येक प्रकारासाठी योग्य दृष्टिकोन वापरतात.