Co kdybyste mohli své databázové objekty (např. tabulky a pohledy) uspořádat do jmenných prostorů podle jejich rolí v systému?
V tomto článku uvidíme správný způsob, jak zacházet se schématy PostgreSQL v Django, a několik malých tipů ohledně Modely Django a Python.

Schéma

Schéma, známé také jako jmenný prostor, je typ databázového objektu, jehož účelem je být hierarchickou organizační vrstvou, která je těsně pod databází.
V PostgreSQL je „veřejné“ výchozí schéma, ale můžete si vytvořit vlastní jmenné prostory pro uspořádání jiných druhů objektů, jako jsou tabulky, pohledy, funkce atd.

Hierarchie databázových objektů

- Server |- Instance PostgreSQL (výchozí port 5432) |- Role (Uživatelé a skupiny) |- Tabulkový prostor |- Databáze |- Spouštěč |- Rozšíření |- Jazyk |- Schéma |- Tabulka |- Zobrazit |- Materializované Zobrazit |- Sekvence |- Funkce |- Postup

O naší laboratoři

To je jednoduchá laboratoř s Django ve virtuálním prostředí (s virtualenv) a PostgreSQL nainstalovaným v localhost.

Python 3.8
Django 3.0
PostgreSQL 12

Mělo by fungovat s mnoha staršími verzemi 🙂

Kódy

> SQL (psql);
$ shell (Linux, FreeBSD, Unix*);
>>> Python shell.

Procvičování

PostgreSQL

Struktura databáze je první věc, kterou uděláme.

Vytvoření uživatele databáze pro aplikaci;
Vytvoření databáze;
Vytvoření schématu;
Vytvoření tabulky

Vytvořme si vlastní příklad ve vestavěném nástroji příkazového řádku psql:

$ psql

Vytvoření uživatelské aplikace:

CREATE ROLE user_test ŠIFROVANÉ HESLO '123' PŘIHLÁŠENÍ;

Databázová role byla vytvořena se zašifrovaným heslem a přihlašovacím atributem (user).

Vytvoření databáze pro testy:

> CREATE DATABASE db_test OWNER user_test;

Databáze je vlastněna „user_test“.

Připojte se k němu jako uživatel „user_test“:

> \c db_test user_test

Uvnitř psql shell \c databáze uživatelské jméno.

Vytvoření schématu:

> VYTVOŘIT SCHÉMA ns_hr;

Jmenný prostor pro náš příklad je připraven!

Zobrazit všechna schémata, která nejsou katalogy:

> SELECTnspname AS jmenný prostorFROM pg_catalog.pg_namespaceWHERE nspname !~ '(^pg_|information_schema)';

Výstup:

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

Všimněte si, že se zobrazí výchozí jmenný prostor (veřejný) a ns_hr, vytvořené pro naši laboratoř.

Vytvoření tabulky ve schématu ns_hr:

> CREATE TABLE ns_hr.tb_person( id_ sériový primární klíč, text jména není null, text příjmení není null);

Jednoduchý stůl…

Stiskněte <Ctrl> + D pro ukončení.

Django

Je čas kódovat v Pythonu! 😀

virtuální prostředí;
instalace modulů Pythonu;
Vytvoření a konfigurace projektu Django;
Vytvoření aplikace Django;
Vytvoření modelu Django;
Migrace;
testy v prostředí shell;

Vytvoření virtuálního prostředí:

$ virtualenv -p `který python3.8` django

Absolutní cesta binárního kódu Pythonu 3.8 byla označena jako Pythonový interpret tohoto prostředí.

Otevřete adresář prostředí a aktivujte jej:

$ cd django &&source bin/activate

Vaše výzva se změnila a začala na „(django)“, což znamená, že vaše virtuální prostředí bylo aktivováno.

Nainstalujte potřebné moduly pro naše testy:

$ pip install django psycopg2-binary configobj ipython

Respektive:Webový framework Django, ovladač PostgreSQL, čtečka konfiguračních souborů a vylepšený interaktivní shell.

Vytvoření nového projektu Django:

$ django-admin startproject my_project

Přejmenujte adresář projektu na src:

$ mv my_project src

Toto je pro usnadnění hierarchie adresářů a neovlivní výsledky. Je to proto, že má stejný název adresáře, který může způsobit určitý zmatek…

Vytvoření konfiguračního souboru databáze:

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

Zde jsme vytvořili samostatný konfigurační soubor pro připojení k databázi.

Upravit hlavní konfigurační soubor projektu:

$ vim src/my_project/settings.py

import osfrom configobj import ConfigObj

Pod importy přidejte řádek, který přináší třídu ConfigObj.

# Database# https://docs.djangoproject.com/en/2.2/ref/settings/#databases# Umístění konfiguračního souboru databázeDB_CONF_FILE =f'{BASE_DIR}/my_project/db.conf'# Přečtěte si konfigurace ze souboruDB_CONFIG =ConfigObj(DB_CONF_FILE)# Parametry databázového připojeníDB_HOST =DB_CONFIG['DB_HOST']DB_NAME =DB_CONFIG['DB_NAME']DB_USER =DB_CONFIG['DB_USER']DB_PASSWORD =DB_CONFIG_CONFIG_DBATADBASSES { 'default':{ 'ENGINE':'django.db.backends.postgresql', 'NAME':DB_NAME, 'USER':DB_USER, 'PASSWORD':DB_PASSWORD, 'HOST':DB_HOST, 'PORT':DB_PORT, } }

Upravte „relaci“ databáze jako výše.

Vytvoření symbolického odkazu pro manage.py:

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

Pro usnadnění naší práce jsme vytvořili symbolický odkaz na manage.py v adresáři bin, který je v naší $PATH.

Spustit virtuální webový server:

$ manage.py runserver 0.0.0.0:8000

Otestujte ve svém prohlížeči:http://localhost:8000 a poté + C přerušte.

Přístup k adresáři projektu:

$ cd src

Pojďme zkontrolovat soubory v aktuálním adresáři:

strom $.

Výstup:

.├── manage.py└── můj_projekt ├── db.conf ├── __init__.py ├── __ccache__ │└ 8. py--.3 v nastavení 3. .pyc │ ├── urls.cpython-38.pyc │ └── wsgi.cpython-38.pyc ├── nastavení.py ├── urls.py └w>─py 
 Seznam obsahu aktuálního adresáře ve stromovém formátu.
Zde vidíme všechny soubory v projektu.
 
 
 
 První migrace pro metadata Django: 
 Migrace $ manage.py
 
 
 
 Vytvoření superuživatele Django: 
 $ manage.py vytvářísuperuser
 
 
 
 Vytvoření aplikace: 
 $ manage.py startapp human_resource
 
 
 
 Upravte soubor settings.py a přidejte novou aplikaci: 
 $ vim my_project/settings.py
 # Definice aplikaceINSTALLED_APPS =[ 'django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django .contrib.staticfiles', # Custom Apps 'human_resource',]
 
 Skvělý trik Django:místo souboru models.py můžete použít adresář models.
Musíte však vytvořit dunder init soubor (__init__.py) v adresáři models.
Jdeme na to!
 
 
 
 Vytvoření adresáře modelů v adresáři aplikace: 
 $ mkdir human_resource/models
 
 
 
 Odstraňte soubor models.py: 
 $ rm -f human_resource/models.py
 
 
 
 Vytvoření modelu: 
 $ vim human_resource/models/hr.py
 z django.db.models import AutoFieldfrom django.db.models import Modelfrom django.db.models import TextFieldclass Osoba(Model):''' Osoba Model Jmenný prostor:ns_hr Tabulka:tb_person ''' id_ =AutoField(db_column='id_', name='id', primary_key=True,) name =TextField(db_column='name', name='name',) prijmeni =TextField(db_column='prijmeni', name='prijmeni',) def __str__(self):return f'{self.name} {self.surname}' class Meta:db_table ='ns_hr"."tb_person' # 'schema"."object' verbose_name_plural ='Person'
 
 Abyste mohli využívat výhod schémat PostgreSQL, uvnitř vašeho modelu, ve vnitřní třídě Meta, k hodnotě atributu „db_table“ musíte vložit tečku, která odděluje jmenný prostor a objekt, do uvozovek.
 
 'schema"."object' 
 
 Objektem může být tabulka nebo pohled, například…
 
 
 
 Dunder init v adresáři modelů, aby se migrace projevily: 
 vim human_resource/models/__init__.py
 z human_resource.models.hr importovat osobu
 
 To je nezbytné pro to, aby adresář models fungoval jako soubor models.py.
 
 
 (Ne) migrace:Moje databáze, moje pravidla!
 
 Vytváříme strukturu naší databáze a žádný ORM by to za nás neměl dělat!
Máme moc!
Máme moc!
Jsme velení!
 
 Naše databáze, naše pravidla! 😉
 
 Stačí si namodelovat databázi vlastníma rukama a provést falešnou migraci Django.
Protože jen my víme, jak musí být databázové objekty vytvořeny 😉
 
 
 
 Proveďte migrace aplikace human_resource: 
 $ manage.py makemigrations human_resource
 
 
 
 Falešná migrace: 
 $ manage.py migrate --fake
 
 
 
 Podívejme se na hierarchii adresářů aplikace: 
 $ tree human_resource/
 human_resource/├── admin.py├── apps.py├── __init__.py├── migrace│ ├── 0001_initial.py└└─_  0001_initial.py└└─. 0001_initial.cpython-38.pyc│ └── __init__.cpython-38.pyc├── modely│ ├── hr.py│ └── py└── py└── py└─ hr_py_.. testů py
 
 
 
 Django Shell (Ipython): 
 $ manage.py shell
 >>> from human_resource.models.hr import Person>>> p =Person(name='Ludwig', surname='van Beethoven')>>> print(p)
 
 Výstup:
 Ludwig van Beethoven
 >>> p.save() # Přetrvávat v databázi
 
 Stiskněte <Ctrl> + D odejít!
 
 
 
 Skořápka databáze (psql): 
 $ manage.py dbshell
 
 Dotaz pro kontrolu, zda data vložil Django:
 > SELECT id_, jméno, příjmení FROM ns_hr.tb_person;
 
 Výstup:
  id | jméno | příjmení ----+--------+--------------- 1 | Ludwig | van Beethoven
 
 
 Závěr
 
 PostgreSQL je robustní a výkonný RDBMS se spoustou funkcí, včetně jmenných prostorů pro jeho objekty.
Django je skvělý webový framework, který je velmi robustní a má také spoustu funkcí.
Takže můžete extrahujte lepší z obou, abyste dosáhli lepších výsledků a k tomu je jedním ze způsobů získání lepší organizace.
Uspořádání databázových objektů do jmenných prostorů podle jejich rolí vám přinese výhody 😉

PostgreSQL schémata / jmenné prostory s Django

Schéma

Hierarchie databázových objektů

O naší laboratoři

Procvičování

PostgreSQL

Django

(Ne) migrace:Moje databáze, moje pravidla!

Závěr