ORM என்றால் என்ன? ஆப்ஸ் தரவுத்தளத்துடன் பேசும் விதம், விளக்கம்

ORM (object-relational mapper) என்பது ஆப்புக்கும் relational database-க்கும் இடையில் அமரும் ஒரு code library. SQL-இல் database queries எழுதுவதற்குப் பதிலாக, டெவலப்பர்கள் தங்கள் நிரலாக்க மொழியில் சாதாரண பொருட்களாக தரவோடு வேலை செய்கிறார்கள் — db.booking.create(...) அல்லது Booking.find(...) போல. ORM அதை SQL ஆக மாற்றி, இயக்கி, முடிவுகளை மீண்டும் பொருட்களாக மாற்றுகிறது. பிரபலமான எடுத்துக்காட்டுகள்: TypeScript-க்கு Prisma மற்றும் Drizzle, Python-க்கு SQLAlchemy, C#-க்கு Entity Framework Core.

AI மூலம் ஆப் உருவாக்கும்போது ORM ஏன் முக்கியம்

AI app builder உங்கள் ஆப்புக்கு database சேர்க்கும்போது, அதனுடன் பேச ஒரு ORM-ஐயும் பொதுவாகச் சேர்க்கும். ORM code நீங்கள் எழுத வேண்டியதில்லை, ஆனால் அது இருக்கிறது என்பதை அறிவது உதவும்:

• உங்கள் data model code-இல் வாழ்கிறது. ORM-இன் schema file பெரும்பாலும் உங்கள் ஆப் தரவின் தெளிவான விளக்கமாக இருக்கும்: எந்த tables உள்ளன, ஒவ்வொன்றிலும் என்ன fields உள்ளன, அவை எப்படி இணைக்கப்பட்டுள்ளன. AI உங்கள் ஆப்பைச் சரியாகப் புரிந்துகொண்டதா என்று சரிபார்க்க இதைப் படிப்பது விரைவான வழி.
• Database மாற்றங்கள் migrations வழியாகச் செல்கின்றன. “customers-க்கு phone number சேர்” என்று கேட்கும்போது, AI model-ஐப் புதுப்பித்து ஒரு migration உருவாக்கும். மாற்றம் நேரடி ஆப்பில் வேலை செய்வதற்கு முன் ஏன் பயன்படுத்தப்பட வேண்டியிருக்கலாம் என்பதை இது புரிய வைக்கிறது.
• இயல்பிலேயே பாதுகாப்பு. ORM queries-ஐ SQL injection-இலிருந்து பாதுகாக்கும் வகையில் உருவாக்குகிறது. Queries-ஐ கையால் இணைக்கும் ஆப்களில் இது மிகவும் பொதுவான பாதுகாப்பு ஓட்டைகளில் ஒன்று.
• வேகத் தடைகள். ஒரே query போதுமான இடத்தில் ORM எளிதாக நூற்றுக்கணக்கான சிறிய queries ஓட்டிவிடலாம். AI-யால் உருவாக்கப்பட்ட ஆப்களில் பக்கங்கள் மெதுவாக இருப்பதற்கு இது பொதுவான காரணம்.

ஒரு அன்றாட உவமை

ஒரே மொழி பேசாத ஒரு பிரிட்டிஷ் பயணியும் ஒரு ஜப்பானியக் கடைக்காரரும் ஒரு மொழிபெயர்ப்பாளர் மூலம் பேசுவதாக கற்பனை செய்யுங்கள்.

பயணி (உங்கள் ஆப்) சொல்கிறார்: “உங்களிடம் உள்ள மூன்று மலிவான தேநீர் வேண்டும்.” மொழிபெயர்ப்பாளர் (ORM) அதை துல்லியமான ஜப்பானிய மொழியாக (SQL) மாற்றி, கடைக்காரரிடம் (database) கொடுக்கிறார்; பதிலை மீண்டும் ஆங்கிலத்தில் மொழிபெயர்க்கிறார்.

பயணி ஜப்பானிய மொழி கற்க வேண்டியதில்லை, பெரும்பாலான உரையாடல்களுக்கு அது சரிதான். ஆனால் சிக்கலான பேரத்திற்கு நேரடியாகப் பேசுவது உதவும் — அதனால்தான் பெரும்பாலான ORM-கள் தேவைப்படும்போது டெவலப்பர்கள் raw SQL எழுத அனுமதிக்கின்றன.

ORM எப்படி வேலை செய்கிறது

Postgres போன்ற databases தரவை rows மற்றும் columns கொண்ட tables-இல் சேமித்து SQL மூலம் கேட்கின்றன. நிரலாக்க மொழிகள் பொருட்களுடன் வேலை செய்கின்றன: ஒரு date, customer, status கொண்ட booking. ORM இரண்டையும் ஒன்றுடன் ஒன்று இணைக்கிறது:

இந்த நான்கு செயல்பாடுகளும் கிட்டத்தட்ட ஒவ்வொரு ஆப்பும் அமைந்திருக்கும் CRUD செயல்கள்.

ஒரு செயல்முறை எடுத்துக்காட்டு: Prisma உடன் bookings

இது ஒரு salon booking ஆப்புக்கான எளிமைப்படுத்தப்பட்ட Prisma schema. இது இரண்டு tables-ஐயும் அவை எப்படி இணைக்கப்பட்டுள்ளன என்பதையும் விவரிக்கிறது:

model Customer {
  id       Int       @id @default(autoincrement())
  name     String
  email    String    @unique
  bookings Booking[]
}

model Booking {
  id         Int      @id @default(autoincrement())
  startsAt   DateTime
  service    String
  customer   Customer @relation(fields: [customerId], references: [id])
  customerId Int
}

எளிய சொற்களில்: ஒரு customer-க்கு ஒரு பெயர், ஒரு தனித்துவமான email, பல bookings உண்டு; ஒவ்வொரு booking-க்கும் ஒரு தொடக்க நேரம், ஒரு service உண்டு, அது ஒரே customer-க்குச் சொந்தமானது.

இப்போது ஆப்புக்கு வேண்டியது: “Lena-வின் வரவிருக்கும் bookings, முதலில் வருபவை முதலில்”:

const bookings = await db.booking.findMany({
  where: {
    customer: { email: "lena@example.com" },
    startsAt: { gte: new Date() },
  },
  orderBy: { startsAt: "asc" },
});

ORM இதை தோராயமாக இப்படிப்பட்ட SQL ஆக மாற்றி, இயக்கி, booking பொருட்களின் பட்டியலைத் திருப்பித் தருகிறது:

SELECT b.* FROM "Booking" b
JOIN "Customer" c ON c.id = b."customerId"
WHERE c.email = $1 AND b."startsAt" >= $2
ORDER BY b."startsAt" ASC;

$1 மற்றும் $2 என்பவை placeholders: email மற்றும் தேதி query உரையிலிருந்து தனியாக அனுப்பப்படுகின்றன — அதுவே SQL injection-ஐத் தடுக்கிறது.

Migrations

பிறகு “வாடிக்கையாளர்கள் phone number சேர்க்கட்டும்” என்று கேட்டால், AI Customer model-இல் phone String? சேர்க்கும் (? என்றால் விருப்பத்தேர்வு என்று பொருள்) மற்றும் ALTER TABLE "Customer" ADD COLUMN "phone" TEXT; போன்ற சிறிய SQL script-ஆன ஒரு migration உருவாக்கும். Migrations வரிசையாகச் சேமிக்கப்படுகின்றன; அதனால் database-இன் ஒவ்வொரு நகலையும் ஒரே அமைப்புக்குக் கொண்டுவரலாம், மாற்றங்களின் வரலாறும் வைக்கப்படுகிறது.

மொழி வாரியாகப் பொதுவான ORM-கள்

ORM-கள் SQL-ஐ எவ்வளவு மறைக்கின்றன என்பதில் வேறுபடுகின்றன. Prisma தனக்கே உரிய schema மொழியையும் query பாணியையும் பயன்படுத்துகிறது; Drizzle SQL-இன் வடிவத்திற்கு நெருக்கமாக இருந்துகொண்டே எல்லாவற்றையும் typed ஆக வைத்திருக்கிறது. Query builders எனப்படும் இலகுவான கருவிகள் — TypeScript-க்கு Knex அல்லது Kysely போன்றவை — முழு object mapping இல்லாமல் code-இல் SQL உருவாக்க உதவுகின்றன.

முக்கிய சொற்கள்

பொதுவான தவறான புரிதல்கள்

• “ORM ஒரு database.” அல்ல. அது ஒரு மொழிபெயர்ப்பாளர். Postgres போன்ற database இன்னும் தேவை.
• “ORM இருந்தால் உங்கள் தரவைப் புரிந்துகொள்ளத் தேவையில்லை.” மோசமாக வடிவமைக்கப்பட்ட tables ORM மூலமாகவும் அதே வலியைத் தரும். நல்ல data model கருவியை விட முக்கியம்.
• “ORM எப்போதும் மெதுவானது.” அன்றாட queries நன்றாகவே இருக்கும். வேகக் குறைவு பெரும்பாலும் N+1 queries அல்லது indexes இல்லாததால் வருகிறது; அவற்றைச் சரிசெய்யலாம்.
• “ORM என்றால் SQL injection ஆபத்து என்றென்றும் இல்லை.” நிலையான ORM முறைகள் பாதுகாப்பானவை, ஆனால் பயனர் உள்ளீட்டை நேரடியாகச் சேர்த்து எழுதப்பட்ட raw SQL இன்னும் ஆபத்தானது.
• “Schema file-ஐ மாற்றினால் நேரடி database மாறும்.” Migration உருவாக்கி அந்த database-க்குப் பயன்படுத்தப்பட்ட பிறகுதான்.

உங்கள் AI builder-இடம் கேட்க வேண்டியவை

• “இந்த database schema-ஐக் காட்டி, ஒவ்வொரு table-ஐயும் உறவையும் எளிய தமிழில் விளக்கு.”
• “இந்த project எந்த ORM பயன்படுத்துகிறது, migrations எங்கே உள்ளன?”
• “எந்த table-ஐயும் மாற்றுவதற்கு முன், ஏற்கனவே உள்ள தரவு பாதிக்கப்படுமா என்று சொல்; தரவு உள்ள column-ஐ கேட்காமல் ஒருபோதும் நீக்காதே.”
• “மெதுவான பக்கங்களில் N+1 queries உள்ளதா என்று பார், பட்டியல்கள் வடிகட்டப்படும் அல்லது வரிசைப்படுத்தப்படும் இடங்களில் indexes சேர்.”
• “பயனர் உள்ளீட்டைப் பயன்படுத்தும் ஒவ்வொரு query-யும் ORM வழியாகவோ parameters-உடனோ செல்வதை உறுதிசெய்; string-ஆக உருவாக்கப்பட்ட SQL வேண்டாம்.”

Mythex-இல் ORM

உங்கள் ஆப்புக்குத் தரவைச் சேமிக்க வேண்டியிருக்கும்போது, Mythex project-க்கு ஒரு பிரத்யேக Postgres database சேர்க்கிறது — chat-இல் கேளுங்கள் அல்லது /database கட்டளையைப் பயன்படுத்துங்கள் — அதன் இணைப்பு விவரங்களை workspace-க்கும் வெளியிடப்பட்ட ஆப்புக்கும் வழங்குகிறது (Database). தரவைப் படிக்கவும் சேமிக்கவும் code-ஐ agent எழுதுகிறது. உங்களுக்கு விருப்பம் இருந்தால் — “Prisma பயன்படுத்து”, “SQLAlchemy பயன்படுத்து”, அல்லது “plain SQL, ORM வேண்டாம்” — அதை chat-இல் சொல்லுங்கள். Schema-ஐ சரிபார்க்க விரும்பும்போதெல்லாம் அதை விளக்கச் சொல்லுங்கள்; code editor-இல் கோப்புகளைப் படிக்கலாம். பெரிய படத்திற்கு, database என்றால் என்ன மற்றும் SQL vs NoSQL ஆகியவற்றைப் பார்க்கவும்.

கேள்விகள்