क्या होगा यदि आप सिस्टम में अपनी भूमिकाओं के अनुसार अपने डेटाबेस ऑब्जेक्ट्स (जैसे टेबल और व्यू) को नेमस्पेस में व्यवस्थित कर सकते हैं?
इस लेख में हम Django में PostgreSQL स्कीमा के साथ संभालने का सही तरीका और कुछ छोटी युक्तियों के बारे में देखेंगे Django मॉडल और पायथन।

स्कीमा

नामस्थान के रूप में भी जाना जाता है, स्कीमा एक प्रकार का डेटाबेस ऑब्जेक्ट है जिसका उद्देश्य एक पदानुक्रमित संगठन परत होना है जो डेटाबेस के ठीक नीचे है।
PostgreSQL पर, "सार्वजनिक" डिफ़ॉल्ट स्कीमा है, लेकिन आप अपना स्वयं का बना सकते हैं अन्य प्रकार की वस्तुओं को व्यवस्थित करने के लिए नाम स्थान जैसे टेबल, दृश्य, कार्य और आदि।

डेटाबेस ऑब्जेक्ट पदानुक्रम

- Server
   |- PostgreSQL Instance (Port 5432 by default)
       |- Role (Users and Groups)
       |- Tablespace
       |- Database
           |- Trigger
           |- Extension
           |- Language
           |- Schema      
               |- Table
               |- View
               |- Materialized View
               |- Sequence
               |- Function
               |- Procedure

हमारी लैब के बारे में

यह एक वर्चुअल वातावरण में Django के साथ एक साधारण लैब है (वर्चुअलएन्व के साथ) और पोस्टग्रेएसक्यूएल लोकलहोस्ट में स्थापित है।

पायथन 3.8
Django 3.0
पोस्टग्रेएसक्यूएल 12

कई पुराने संस्करणों के साथ काम करना चाहिए 🙂

कोड

> एसक्यूएल (psql);
$ खोल (लिनक्स, फ्रीबीएसडी, यूनिक्स*);
>>> पायथन शेल।

अभ्यास

पोस्टग्रेएसक्यूएल

डेटाबेस संरचना सबसे पहले हम करेंगे।

एप्लिकेशन के लिए डेटाबेस उपयोगकर्ता का निर्माण;
डेटाबेस निर्माण;
स्कीमा निर्माण;
टेबल बनाना

आइए psql बिल्ड-इन कमांड लाइन टूल में अपना खुद का उदाहरण बनाएं:

$ psql

उपयोगकर्ता एप्लिकेशन का निर्माण:

CREATE ROLE user_test ENCRYPTED PASSWORD '123' LOGIN;

डेटाबेस भूमिका एक एन्क्रिप्टेड पासवर्ड और लॉगिन विशेषता (उपयोगकर्ता) के साथ बनाई गई थी।

परीक्षणों के लिए डेटाबेस का निर्माण:

> CREATE DATABASE db_test OWNER user_test;

डेटाबेस "user_test" के स्वामित्व में है।

इसे उपयोगकर्ता “user_test” के रूप में कनेक्ट करें:

> \c db_test user_test

Psql शेल के अंदर \c डेटाबेस उपयोगकर्ता नाम।

स्कीमा बनाना:

> CREATE SCHEMA ns_hr;

हमारे उदाहरण के लिए नाम स्थान तैयार है!

सभी स्कीमा दिखाएं जो कैटलॉग नहीं हैं:

> SELECT
nspname AS namespace
FROM pg_catalog.pg_namespace
WHERE nspname !~ '(^pg_|information_schema)';

आउटपुट:

namespace 
-----------
 public
 ns_hr

ध्यान दें कि डिफ़ॉल्ट नाम स्थान (सार्वजनिक) और ns_hr, हमारी प्रयोगशाला के लिए बनाया गया है।

ns_hr स्कीमा में तालिका बनाना:

> CREATE TABLE ns_hr.tb_person(
    id_ serial primary key,
    name text not null,
    surname text not null
);

एक साधारण तालिका…

हिट <Ctrl> + D बाहर निकलने के लिए।

Django

यह पायथन में कोड करने का समय है!

आभासी वातावरण;
पायथन मॉड्यूल इंस्टालेशन;
Django प्रोजेक्ट निर्माण और कॉन्फ़िगरेशन;
Django ऐप बनाना;
Django मॉडल निर्माण;
माइग्रेशन;
खोल में परीक्षण;

आभासी परिवेश निर्माण:

$ virtualenv -p `which python3.8` django

पायथन 3.8 के बाइनरी के पूर्ण पथ को इस वातावरण के पायथन दुभाषिया के रूप में इंगित किया गया था।

पर्यावरण की निर्देशिका एक्सेस करें और इसे सक्रिय करें:

$ cd django && source bin/activate

आपका संकेत बदल गया, "(django)" पर शुरू हुआ, यह दर्शाता है कि आपका आभासी वातावरण सक्रिय था।

हमारे परीक्षणों के लिए आवश्यक मॉड्यूल स्थापित करें:

$ pip install django psycopg2-binary configobj ipython

क्रमशः:Django वेब फ्रेमवर्क, PostgreSQL ड्राइवर, कॉन्फ़िगरेशन फ़ाइल रीडर और बेहतर इंटरैक्टिव शेल।

नई Django परियोजना निर्माण:

$ django-admin startproject my_project

परियोजना की निर्देशिका का नाम बदलकर src करें:

$ mv my_project src

यह निर्देशिका पदानुक्रम को आसान बनाने के लिए है और परिणामों को प्रभावित नहीं करेगा। ऐसा इसलिए है क्योंकि इसमें एक ही नाम निर्देशिका है जो कुछ भ्रम पैदा कर सकती है…

डेटाबेस कॉन्फ़िगरेशन फ़ाइल निर्माण:

$ cat << EOF > src/my_project/db.conf
DB_HOST = 'localhost'
DB_NAME = 'db_test'
DB_USER = 'user_test'
DB_PASSWORD = '123'
DB_PORT = 5432
EOF

यहां हमने डेटाबेस कनेक्शन के लिए एक अलग कॉन्फ़िगरेशन फ़ाइल बनाई है।

प्रोजेक्ट की मुख्य कॉन्फ़िगरेशन फ़ाइल संपादित करें:

$ vim src/my_project/settings.py

import os

from configobj import ConfigObj

आयात के नीचे एक पंक्ति जोड़ें जो ConfigObj वर्ग लाती है।

# Database
# https://docs.djangoproject.com/en/2.2/ref/settings/#databases

# Database configuration file location
DB_CONF_FILE = f'{BASE_DIR}/my_project/db.conf'

# Read the configurations from file
DB_CONFIG = ConfigObj(DB_CONF_FILE)

# Database connection parameters

DB_HOST = DB_CONFIG['DB_HOST']
DB_NAME = DB_CONFIG['DB_NAME']
DB_USER = DB_CONFIG['DB_USER']
DB_PASSWORD = DB_CONFIG['DB_PASSWORD']
DB_PORT = DB_CONFIG['DB_PORT']

DATABASES = {
             'default': {
                         'ENGINE': 'django.db.backends.postgresql',
                         'NAME': DB_NAME,
                         'USER': DB_USER,
                         'PASSWORD': DB_PASSWORD,
                         'HOST': DB_HOST,
                         'PORT': DB_PORT,
                         }
            }

ऊपर के रूप में डेटाबेस "सत्र" को संशोधित करें।

manage.py के लिए प्रतीकात्मक लिंक निर्माण:

$ ln -s `pwd`/src/manage.py `pwd`/bin/manage.py

अपने काम को आसान बनाने के लिए हमने बिन निर्देशिका में manage.py के लिए एक प्रतीकात्मक लिंक बनाया जो हमारे $PATH में है।

वर्चुअल वेब सर्वर चलाएं:

$ manage.py runserver 0.0.0.0:8000

अपने ब्राउज़र में परीक्षण करें:http://localhost:8000 और फिर + C निरस्त करने के लिए।

प्रोजेक्ट निर्देशिका तक पहुंचें:

$ cd src

आइए वर्तमान निर्देशिका के अंदर की फाइलों की जांच करें:

$ tree .

आउटपुट:

.
├── manage.py
└── my_project
    ├── db.conf
    ├── __init__.py
    ├── __pycache__
    │   ├── __init__.cpython-38.pyc
    │   ├── settings.cpython-38.pyc
    │   ├── urls.cpython-38.pyc
    │   └── wsgi.cpython-38.pyc
    ├── settings.py
    ├── urls.py
    └── wsgi.py

वर्तमान निर्देशिका की सामग्री को ट्री-जैसे प्रारूप में सूचीबद्ध करें।
यहां हम प्रोजेक्ट के अंदर सभी फाइलें देखते हैं।

Django मेटाडेटा के लिए पहला माइग्रेशन:

$ manage.py migrate

Django के सुपर उपयोगकर्ता का निर्माण:

$ manage.py createsuperuser

एप्लिकेशन बनाएं:

$ manage.py startapp human_resource

नया ऐप जोड़ने के लिए settings.py संपादित करें:

$ vim my_project/settings.py

# Application definition

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',

    # Custom Apps
    'human_resource',
]

एक बढ़िया Django ट्रिक:आप model.py फ़ाइल के बजाय एक निर्देशिका मॉडल का उपयोग कर सकते हैं।
लेकिन आपको मॉडल निर्देशिका के अंदर एक डंडर init फ़ाइल (__init__.py) बनानी होगी। पी>

एप्लिकेशन निर्देशिका के अंदर मॉडल निर्देशिका बनाना:

$ mkdir human_resource/models

models.py फ़ाइल निकालें:

$ rm -f human_resource/models.py

मॉडल निर्माण:

$ vim human_resource/models/hr.py

from django.db.models import AutoField
from django.db.models import Model
from django.db.models import TextField


class Person(Model):
    '''
    Person Model

    Namespace: ns_hr
    Table: tb_person
    '''

    id_ = AutoField(db_column='id_', name='id', primary_key=True,)
    name = TextField(db_column='name', name='name',)
    surname = TextField(db_column='surname', name='surname',)

    def __str__(self):
        return f'{self.name} {self.surname}'

    class Meta:
        db_table = 'ns_hr"."tb_person'  # 'schema"."object'
        verbose_name_plural = 'Person'

PostgreSQL स्कीमा के लाभों का आनंद लेने के लिए, अपने मॉडल के अंदर, मेटा इनर क्लास में, "db_table" विशेषता के मान के लिए आपको एक बिंदु रखना होगा जो उद्धरण चिह्नों के बीच नामस्थान और ऑब्जेक्ट को अलग करता है।

'schema"."object'

ऑब्जेक्ट एक टेबल या एक दृश्य हो सकता है, उदाहरण के लिए…

माइग्रेशन प्रभावी होने के लिए मॉडल निर्देशिका के अंदर Dunder init:

vim human_resource/models/__init__.py

from human_resource.models.hr import Person

मॉडल निर्देशिका के लिए यह आवश्यक है कि model.py फ़ाइल के रूप में कार्य करता है।

(नहीं) माइग्रेशन:मेरा डेटाबेस, मेरे नियम!

हम अपने डेटाबेस की संरचना बनाते हैं और कोई ORM हमारे लिए यह नहीं करता है!
हमारे पास शक्ति है!
हमारे पास ताकत है!
हम कमांड में हैं!

हमारा डेटाबेस, हमारे नियम!

बस अपने डेटाबेस को अपने हाथों से मॉडल करें और नकली Django माइग्रेशन करें।
क्योंकि केवल हम ही जानते हैं कि डेटाबेस ऑब्जेक्ट कैसे बनाया जाना चाहिए 😉

मानव_संसाधन ऐप के लिए माइग्रेशन करें:

$ manage.py makemigrations human_resource

नकली माइग्रेशन:

$ manage.py migrate --fake

आइए एप्लिकेशन की निर्देशिका पदानुक्रम की जांच करें:

$ tree human_resource/

human_resource/
├── admin.py
├── apps.py
├── __init__.py
├── migrations
│   ├── 0001_initial.py
│   ├── __init__.py
│   └── __pycache__
│       ├── 0001_initial.cpython-38.pyc
│       └── __init__.cpython-38.pyc
├── models
│   ├── hr.py
│   ├── __init__.py
│   └── __pycache__
│       ├── hr.cpython-38.pyc
│       └── __init__.cpython-38.pyc
├── __pycache__
│   ├── admin.cpython-38.pyc
│   └── __init__.cpython-38.pyc
├── tests.py
└── views.py

Django Shell (Ipython):

$ manage.py shell

>>> from human_resource.models.hr import Person

>>> p = Person(name='Ludwig', surname='van Beethoven')                                                                         

>>> print(p)

आउटपुट:

Ludwig van Beethoven

>>> p.save()   # Persist in database

हिट <Ctrl> + D बाहर निकलने के लिए!

डेटाबेस शेल (psql):

$ manage.py dbshell

यह जांचने के लिए एक प्रश्न कि क्या डेटा Django द्वारा डाला गया था:

>  SELECT id_, name, surname FROM ns_hr.tb_person;

आउटपुट:

 id |  name  |    surname    
----+--------+---------------
  1 | Ludwig | van Beethoven

निष्कर्ष

पोस्टग्रेएसक्यूएल एक मजबूत और शक्तिशाली आरडीबीएमएस है जिसमें बहुत सारी विशेषताएं हैं, जिसमें इसके ऑब्जेक्ट के लिए नाम स्थान शामिल हैं। बेहतर परिणाम प्राप्त करने के लिए दोनों में से बेहतर निकालें और ऐसा करने के लिए, बेहतर संगठन प्राप्त करने का एक तरीका है।
अपने डेटाबेस ऑब्जेक्ट को नामस्थानों में उसकी भूमिकाओं के अनुसार व्यवस्थित करना आपके लिए लाभ लाएगा 😉

Django के साथ PostgreSQL स्कीमा / नेमस्पेस

स्कीमा

डेटाबेस ऑब्जेक्ट पदानुक्रम

हमारी लैब के बारे में

अभ्यास

पोस्टग्रेएसक्यूएल

Django

(नहीं) माइग्रेशन:मेरा डेटाबेस, मेरे नियम!

निष्कर्ष