ऑब्जेक्ट-रिलेशनल मैपिंग (ORM) और माइग्रेशन, SQL और रिलेशनल डेटाबेस की दुनिया में मूलभूत अवधारणाएं हैं। ORM डेवलपर्स के लिए SQL की जटिलताओं को अमूर्त (abstract) करके, प्रोग्रामिंग भाषाओं का उपयोग करते हुए डेटाबेस के साथ इंटरैक्ट करने का एक सुविधाजनक तरीका प्रदान करते हैं। डेटा मॉडलिंग से लेकर SQL निर्माण और एड-हॉक क्वेरी तक, अलग-अलग ORM विभिन्न उपयोग के मामलों और उपयोगकर्ता प्राथमिकताओं के लिए उपयुक्त अलग-अलग सुविधाएँ, इंटरफ़ेस और नियंत्रण के स्तर प्रदान करते हैं।

तुलनात्मक रूप से, माइग्रेशन का तात्पर्य समय के साथ डेटाबेस के स्कीमा में किए गए नियंत्रित परिवर्तनों या संशोधनों से है, जो बदलती विशिष्टताओं या आवश्यकताओं के अनुसार प्रोजेक्ट डेटाबेस के विकास, लचीलेपन और अनुकूलन क्षमता को आधार प्रदान करते हैं। चाहे इसमें टेबल बनाना, इंडेक्स जोड़ना, कॉलम के प्रकार बदलना या अन्य कार्य शामिल हों, माइग्रेशन डेटाबेस स्कीमा को मैन्युअल रूप से बदलने की आवश्यकता को समाप्त कर देते हैं।

हम लोकप्रिय ORM की तुलना करेंगे, जिसमें डेटा मॉडलिंग क्षमताओं, SQL निर्माण, एड-हॉक क्वेरी और डेवलपर्स को मिलने वाले सटीक नियंत्रण की डिग्री पर ध्यान केंद्रित किया जाएगा। इसके बाद, हम डेटाबेस माइग्रेशन में गहराई से उतरेंगे, और SQL तथा रिलेशनल डेटाबेस के संदर्भ में उनकी कार्यक्षमता और प्रभाव को उजागर करेंगे। एक नया डेटाबेस बनाने से लेकर परिवर्तनों को ट्रैक करने और डेटाबेस की अखंडता सुनिश्चित करने तक, विभिन्न माइग्रेशन रणनीतियाँ डेटाबेस प्रबंधन के लिए मूल्यवान नियंत्रण और सरलता के विभिन्न स्तर प्रदान करती हैं।

• ActiveRecord एप्लिकेशन के लिए लगभग शून्य-कॉन्फ़िगरेशन पर्सिस्टेंस लेयर स्थापित करने के लिए क्लास को रिलेशनल डेटाबेस टेबल से जोड़ता है।
• Ecto डेटा मैपिंग और भाषा एकीकृत क्वेरी के लिए एक टूलकिट है।
• SqlAlchemy पायथन के लिए डेटाबेस टूलकिट है।
• Drizzle SQL डेटाबेस के लिए एक TypeScript ORM है जिसे अधिकतम टाइप सुरक्षा को ध्यान में रखकर डिज़ाइन किया गया है।
• Knex जावास्क्रिप्ट के लिए एक बैटरी-शामिल, मल्टी-डायलेक्ट (PostgreSQL, MySQL, CockroachDB, MSSQL, SQLite3, Oracle (Oracle वॉलेट प्रमाणीकरण सहित)) क्वेरी बिल्डर है।
• Conman कनेक्शन को प्रबंधित करने के लिए एक गतिशील चर (dynamic variable) पर निर्भर करता है। गतिशील चर कनेक्शन को लेनदेन के लिए संदर्भानुसार रिबाउंड करने की अनुमति देता है। कई डेटाबेस के साथ काम करते समय, प्रत्येक डेटाबेस कनेक्शन को ट्रैक करने के लिए एक अलग चर की आवश्यकता होती है।
• HoneySQL Clojure डेटा संरचनाओं के रूप में SQL है। प्रोग्रामेटिक रूप से क्वेरी बनाएं – रनटाइम पर भी – बिना स्ट्रिंग्स को एक साथ जोड़े।

services:
  db:
    container_name: ubntth_pg
    image: postgres
    restart: always
    environment:
      POSTGRES_USER: root
      POSTGRES_PASSWORD: root
      POSTGRES_DB: ubntth_db
    ports:
      - "5432:5432"
  pgadmin:
    container_name: ubntth_pgadmin4
    image: dpage/pgadmin4
    restart: always
    environment:
      PGADMIN_DEFAULT_EMAIL: root@admin.com
      PGADMIN_DEFAULT_PASSWORD: root
    ports:
      - "5050:80"

export DB_HOST=127.0.0.1
export DB_PORT=5432
export DB_USER=root
export DB_PASS=root
export DB_NAME=ubntth_db
export DB_URL=postgres://root:root@127.0.0.1:5432/ubntth_db

{
  "name": "orms_and_migrations",
  "version": "1.0.0",
  "description": "ORMs and Migrations",
  "main": "run.mjs",
  "scripts": {
    "dev": "bun run.mjs",
    "gen:migration": "drizzle-kit generate:pg --schema=./schema.mjs",
    "run:migration": "bun ./src/schema.mjs",
    "drizzle-studio": "bunx drizzle-kit studio",
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [
    "PostgresSQL",
    "Javascript",
    "SQL",
    "Databases"
  ],
  "author": "ChiefKemist",
  "license": "ISC",
  "dependencies": {
    "drizzle-orm": "^0.28.6",
    "elysia": "^0.6.19",
    "pg": "^8.11.3"
  },
  "devDependencies": {
    "@types/pg": "^8.10.2",
    "drizzle-kit": "^0.19.13"
  }
}

/** @type { import("drizzle-kit").Config } */
export default {
  schema: "./schema.mjs",
  driver: 'pg',
  dbCredentials: {
    connectionString: Bun.env.DB_URL,
  }
};

import { drizzle } from "drizzle-orm/node-postgres";
import { Client } from "pg";

export const connect = () => {
    const client = new Client({
        connectionString: "postgres://user:password@host:port/db",
    });

    // or
    const client = new Client({
        host: Bun.env.DB_HOST,
        port: Bun.env.DB_PORT,
        user: Bun.env.DB_USER,
        password: Bun.env.DB_PASS,
        database: Bun.env.DB_NAME,
    });

    await client.connect();
    const db = drizzle(client);

    return db
};

import { pgTable, serial, text, varchar } from "drizzle-orm/pg-core";

export const users = pgTable('users', {
  id: serial('id').primaryKey(),
  fullName: varchar('full_name', { length: 256 }),
  //phone: varchar('phone', { length: 256 }),
}, (users) => ({
  nameIdx: index('name_idx').on(users.fullName),
}));

//export const accounts = pgTable('accounts', {
//  id: serial('id').primaryKey(),
//  bankName: varchar('bank_name', { length: 256 }),
//  //accountNumber: varchar('account_number', { length: 256 }),
//  userId: int('user_id').references(() => users.id),
//});

import { drizzle } from "drizzle-orm/postgres-js";
import { migrate } from "drizzle-orm/postgres-js/migrator";
import postgres from "postgres";
import { connect } from "./connection"l

//const sql = postgres("...", { max: 1 })
//const db = drizzle(sql);

const db = connect();

await migrate(db, { migrationsFolder: "drizzle" });

पॉल ग्राहम द्वारा विभिन्न प्रोग्रामिंग भाषाओं के सापेक्ष गुणों पर चर्चा करने वाले एक निबंध में पेश की गई 'ब्लब विरोधाभास' (Blub paradox) अवधारणा, एक सैद्धांतिक प्रोग्रामर से संबंधित है जो अपनी पसंदीदा भाषा से अधिक उन्नत किसी भी भाषा को अनावश्यक और अत्यधिक जटिल मानता है क्योंकि वह उसकी बेहतर सुविधाओं और क्षमताओं को समझने में असमर्थ होता है। इस अवधारणा का नाम काल्पनिक "ब्लब" प्रोग्रामिंग भाषा से लिया गया है, जो भाषा दक्षता के केंद्र में स्थित है। "ब्लब" का उपयोग करने वाले व्यक्ति इसे पर्याप्त कार्यक्षमता वाला मान सकते हैं, लेकिन वे उन भाषाओं से भयभीत महसूस कर सकते हैं जो अधिक अमूर्तता प्रदान करती हैं, इसके विपरीत उन लोगों के विपरीत जो अधिक शक्तिशाली भाषाओं का उपयोग करते हैं, जैसे ग्राहम के दृष्टिकोण में Lisp, जो अपनी कोडिंग दक्षता को अनुकूलित करने के लिए इसकी अतिरिक्त सुविधाओं का लाभ उठाने में सक्षम हैं।

"ब्लब" विरोधाभास का ऑब्जेक्ट-रिलेशनल मैपिंग (ORM) विकल्पों और SQL तथा रिलेशनल डेटाबेस जैसे तत्वों के साथ भी विभिन्न तरीकों से गहरा संबंध है। उदाहरण के लिए, डेटा मॉडलिंग और डेटाबेस माइग्रेशन, उपयोग किए जा रहे ORM पर निर्भर करते हैं। "ब्लब" भाषाओं में अवधारणाबद्ध ORM पंक्तियों का ऑब्जेक्ट्स के साथ एक रैखिक मैपिंग प्रदान करते हैं, जो CRUD (Create, Read, Update, Delete) जैसे बुनियादी कार्यों में सहायता करते हैं, और जटिल लेनदेन, स्वचालित स्कीमा माइग्रेशन, और उन्नत कैशिंग जैसी अतिरिक्त सुविधाएँ प्रदान करते हैं, हालाँकि लीकी एब्स्ट्रैक्शन और कठोरता जैसी सीमाओं के साथ। हालाँकि, Lisp भाषाओं में बनाए गए ORM मैक्रोज़ के उपयोग के कारण मूल (native) प्रतीत होते हैं और उत्पादकता या कोडिंग दक्षता से समझौता किए बिना उन्नत सुविधाएँ प्रदान करने में सक्षम हैं।

संक्षेप में, ब्लब विरोधाभास का अर्थ है कि प्रोग्रामर अनजाने में अधिक शक्तिशाली ORM और भाषाओं की उन्नत क्षमताओं को कम करके आंक सकते हैं क्योंकि वे परिचित भाषाओं की सरलता के मूल्य को अधिक आंकते हैं और अपरिचित भाषाओं के संभावित लाभों को कम आंकते हैं। जबकि "ब्लब" भाषाओं में तैयार किए गए ORM सुविधा और सरलता का आकर्षण प्रदान कर सकते हैं, 'Lisp' या अन्य उच्च-स्तरीय भाषाओं में विकसित किए गए ORM आमतौर पर अधिक शक्ति और अनुकूलन क्षमता प्रस्तुत करते हैं, विशेष रूप से SQL और रिलेशनल डेटाबेस के साथ जटिल डेटा हेरफेर कार्यों के साथ काम करते समय।