PostgreSQL-இல் schemas என்றால் என்ன?

Question

Accepted Answer

ஒரு **schema** என்பது PostgreSQL-இல் ஒரு **namespace** — ஒரு database-ன் உள்ளே இருக்கும் ஒரு logical container, இது தொடர்புடைய tables, views, functions, மற்றும் பிற objects-ஐ group செய்கிறது. Schemas-கள் objects-ஐ ஒழுங்குபடுத்த உதவுகின்றன மற்றும் naming collisions-ஐ தவிர்க்கின்றன; default schema `public` ஆகும்.

## Schemas ஒரு database-ன் உள்ளே objects-ஐ ஒழுங்குபடுத்துகிறது

```text
A PostgreSQL server can have multiple DATABASES.
Each database can have multiple SCHEMAS (namespaces).
Each schema contains TABLES, views, functions, etc.
→ Hierarchy: server → database → schema → tables/objects
```

```sql
CREATE SCHEMA sales;                    -- create a schema
CREATE TABLE sales.orders (...);         -- a table IN the sales schema (qualified name)
SELECT * FROM sales.orders;              -- reference with schema.table

-- the default schema is `public` — unqualified objects go there
CREATE TABLE users (...);                -- actually public.users
```

Objects-குறிப்பு `schema.object` என உறவுப்படுத்தப்படுகிறது. ஒரு schema prefix இல்லாமல், Postgres **search path**-ஐ பயன்படுத்துகிறது (default: `public`).

## Search path

```sql
SHOW search_path;                        -- default: "$user", public
SET search_path TO sales, public;        -- look in sales first, then public
SELECT * FROM orders;                    -- finds sales.orders (no prefix needed)
```

**Search path** என்பது Postgres-ஐ qualified names இல்லாத பெயர்களுக்கு எந்த schemas-இல் பார்க்க வேண்டும் என்பதை தீர்மானிக்கிறது — இதை setting செய்வதால் நீங்கள் ஒரு தேர்ந்த schema-ன் உள்ளே short names-ஐ பயன்படுத்தலாம்.

## Schemas ஏன் பயன்படுத்த வேண்டும்

```text
✓ ORGANIZATION — group related objects (e.g. `sales`, `inventory`, `auth` schemas)
✓ Avoid naming collisions — two schemas can each have an `orders` table
✓ MULTI-TENANCY — a schema per tenant (isolating each customer's data)
✓ SECURITY/permissions — grant access per schema
✓ Separating concerns — e.g. an `app` schema vs an `analytics` schema
```

ஒரு common pattern என்பது multi-tenant applications-இல் **schema per tenant** அல்லது domain/module-ஆல் grouping ஆகும்.

## அது ஏன் முக்கியம்

Schemas என்பது **database objects-ஐ ஒழுங்குபடுத்தக்கூடிய** ஒரு useful PostgreSQL feature ஆகும், மற்றும் அவற்றை புரிந்துகொள்வது databases-ஐ நன்றாக structure செய்வதற்கு மதிப்பான ஒன்று ஆகும், குறிப்பாக அவை grow அடைகின்றபோது அல்லது பல tenants-ஐ serve செய்கின்றபோது.

ஒரு schema என்பது database-ன் உள்ளே ஒரு namespace ஆகும் என்பதைப் புரிந்துகொள்வது (tables, views, functions-ஐ grouping செய்கிறது) — server → database → schema → objects-ன் hierarchy உடன் — Postgres objects-ஐ எவ்வாறு organize செய்கிறது மற்றும் அவற்றுக்கு செந்தரப்படுத்துவது செய்வது (`schema.object`, அல்லது **search path**-ஐ qualified names இல்லாத பெயர்களுக்கு நம்பியிருந்து, default `public`-ஐ) என்பதை தெளிவுபடுத்துகிறது.

**practical uses**-ஐ அறிந்திருப்பது key value ஆகும்: schemas organization (domain/module-ஆல் தொடர்புடைய objects-ஐ grouping செய்வது — `auth`, `sales`, `analytics`), naming collisions-ஐ தவிர்ப்பது (different schemas-ஆல் same-named tables-ஐ பெற முடியும்), per-schema security/permissions-ஐ enable செய்வது, மற்றும் **multi-tenancy**-ஐ crucially support செய்வது (ஒரு tenant per schema-ன் common pattern — ஒவ்வொரு customer-ன் data-ஐ isolate செய்ய — SaaS applications-க்கு ஒரு முக்கியமான architectural option).

Schemas மற்றும் search path-ஐ புரிந்துகொள்வது ஒரு database-ஐ cleanly organize செய்ய உதவுகிறது, `public`-இல் எல்லாவற்றையும் put செய்வதன் clutter மற்றும் collisions-ஐ தவிர்க்கிறது, மற்றும் multi-tenancy போன்ற patterns-ஐ implement செய்கிறது.

Database objects-ஐ logically organize செய்வது maintainability-க்கு முக்கியமாக உள்ளது (குறிப்பாக larger applications-இல்), மற்றும் schemas important patterns-ஐ enable செய்வதால் (domain separation, multi-tenancy, per-schema security), PostgreSQL schemas-ஐ புரிந்துகொள்வது — அவை என்ன, search path, மற்றும் அவற்றின் practical uses — Postgres databases-ஐ effectively structure செய்வதற்கு valuable, practically-relevant knowledge ஆகும், particularly larger அல்லது multi-tenant applications-க்கு relevant, இங்கு good object organization முக்கியமாக உள்ளது.