flask database handling how use flask with database
V tomto výukovém programu Flask Database se naučíte používat Flask s různými databázemi, jako je Flask MySQL, Flask MongoDB, SQLite atd.
Rozšíříme koncepty obsažené v našem prvním kurzu Flask Python. Začneme tím, že použijeme Flask s MongoDB, dokumentární databází NoSQL, kde NoSQL znamená nejen SQL.
Nejprve pokryjeme koncept propojení s databází a poté vám dáme vědět, jak se nezamknout pomocí jedné databáze. V případě potřeby můžeme upravit pouze konfigurace, abychom změnili back-end databáze.
=> Podívejte se na průvodce Perfect Flask Training Guide zde
Co se naučíte:
Výukový program pro baňkovou databázi
V tomto kurzu mohou čtenáři nakreslit srovnání mezi diskutovanými databázemi. Dále mluvíme o Flask-MongoEngine, Flask-SQLAlchemy a Flask MongoAlchemy. Tyto dva ORM, tj. Object Relation Mapper, jsou docela populární.
ORM pod kapotou transparentně překládají objekty (databázové modely) do databázových příkazů nebo příkazů SQL.
Výhody používání ORM jsou uvedeny níže:
- Vývojáři mohou místo tabulek a SQL pracovat s objekty.
- Pomocí migrací můžete sledovat aktualizace databáze.
- Snižuje náklady na vývoj a čas.
- Překonává rozdíly SQL specifické pro databázi.
Při použití ORM nemusí programátoři psát složité dotazy a příkazy SQL, aby mohli provádět základní příkazy SQL.
Připojit k databázi
Otevřete konfigurační soubor a všimněte si níže uvedených hodnot. Flask-Appbuilder převezme ze zmíněných hodnot podrobnosti databáze na připojovacím řetězci.
# The MongoEngine connection string. MONGODB_SETTINGS = { 'DB': 'mydb', 'connect': False, }
Všechny nízkoúrovňové funkce správy databáze pomocí ORM byly zabaleny pod příkazy Flask Click, které vidíme pomocí flask fab - help na příkazovém řádku.
Baňka MongoDB
V této části se naučíme, jak používat ORM namísto použití surových skriptů SQL pro práci s databázemi v baňce.
MongoDB je nerelační databáze založená na dokumentech. Už jsme to nakonfigurovali s naší aktuální ukázkovou aplikací pro flaskové ukázky.
Pomocí níže uvedených příkazů můžete spravovat server MongoDB na místním počítači.
sudo systemctl start mongod # to start MongoDB sudo systemctl stop mongod # to stop MongoDB sudo systemctl status mongod # to check status MongoDB
Diskutovali jsme o dvou slavných ORM, které můžete použít s MongoDB a Flask.
Pomocí návrháře databází jsme vytvořili dvě tabulky s názvem Album a Song a definovali jsme vztah mezi dvěma mezi Album a Song. Níže je uveden obrázek, který zobrazuje totéž.
Baňkový MongoEngine
Nyní vytvořme náš první model MongoEngine DB.
Vytvořte nebo upravte soubor models.py v adresáři aplikace a přidejte následující kód.
from mongoengine import Document from mongoengine import DateTimeField, StringField, ReferenceField, ListField, IntField class Album(Document): name = StringField(unique=True, required=True, max_lenth=100) def __str__(self): return self.name class Song(Document): title = StringField(max_lenth=200, required=True, unique=True) rating = IntField(default=0,max_lenth=1) # 1 to 9 album = ReferenceField(Album) def __str__(self): return self.title
Vytvořili jsme dva modely MongoEngine s názvem Album a píseň. Tyto modely odpovídají příslušným dokumentům v MongoDB.
Album má jedno pole typového řetězce s určitými omezeními.
- Název alba je jedinečný.
- Název alba nesmí být prázdný.
- Název alba může mít maximálně sto znaků.
Podobně dokument Song má název, pole hodnocení a referenční pole, které ukazuje na jiný dokument, Album. Uložme tento soubor a vytvořme data pomocí těchto dvou modelů. Přejděte do kořenového adresáře projektu a pomocí příkazu flask shell přejděte do aplikace flask v prostředí Python.
Jakmile zadáte shell, použijte níže uvedené příkazy pro přístup k modelům MongoEngine a vytvoření ukázkových dat, jak je znázorněno níže.
>>> from app.models import Album, Song >>> album1 = Album(name='Album1') >>> album1.save() >>> song1 = Song(title='Song1', rating=9, album=album1) >>> song1.save()
Nyní pojďme přistupovat k databázi pomocí klienta Mongo a uvidíme, zda jsou data uložena jako výsledek výše uvedených prohlášení. Ve výše uvedeném kódu nejprve importujeme Album a Skladbu a poté vytvoříme jejich objekty s požadovanými hodnotami parametrů.
Zde jsou parametry názvy polí, jak jsou definovány v modelech, a naše data zmiňujeme jako hodnoty těchto parametrů. Jakmile je vytvoření objektu úspěšné, zavoláme metodu uložení na příslušné objekty, abychom uložili dokumenty do databáze.
Pomocí příkazu mongo přejděte do MongoDB. Jakmile se připojíte k serveru pomocí klienta mongo, použijte níže uvedené příkazy.
# 1) Zkontrolujte seznam databází
podřetězec (0,0)
> show dbs #----- output ---- admin 0.000GB config 0.000GB local 0.000GB mydb 0.001GB #----- output ----
# 2) Použijte naši databázi s názvem mydb
> use mydb #----- output ---- switched to db mydb #----- output ----
# 3) Zkontrolujte kolekce a.k.a tabulek v RDBMS
> show collections #----- output ---- album permission permission_view role song user view_menu #----- output ----
# 4) Seznam libovolného dokumentu ve sbírce alb.
> db.album.findOne() #----- output ---- { '_id' : ObjectId('5eddb43b8b1e179bef87d41d'), 'name' : 'Album1' } #----- output ----
# 5) Seznam libovolného dokumentu ve sbírce skladeb.
> db.song.findOne() #----- output ---- { '_id' : ObjectId('5eddb74b0177c8f096d880ec'), 'title' : 'Song1', 'rating' : 9, 'album' : ObjectId('5eddb43b8b1e179bef87d41d') } #----- output ----
Pokud jste pracovali s Django, pak si uvědomíte, že MongoEngine funguje velmi podobně jako Django zabudovaný ORM. V posledním výstupu, když jsme dotazovali skladbu, si všimněte, jaký je odkaz na jiný dokument pro pole alba.
Nyní pojďme vytvořit další album a provést aktualizaci stávajícího dokumentu písně.
>>> from app.models import Album, Song >>> album2 = Album(name='Album2') >>> album2.save() >>> songs_q = Song.objects(title='Song1') # query the database >>> songs_q.count() 1 >>> song1 = songs_q[0] >>> song1.album = album2 # update the album field >>> song1.save()
Importujeme oba modely, tj. Album a Song. Poté vytvořte nový dokument s názvem album2. Kolekce Query Song v databázi a získejte skladbu pomocí jejího názvu. Poté přistupujeme k objektu pomocí indexu pole výsledku dotazu, aktualizujeme pomocí operátoru přiřazení a uložíme aktualizovaný dokument.
Nyní zkontrolujeme uložené sbírky znovu pomocí klienta Mongo.
> db.album.find().pretty() ## output { '_id' : ObjectId('5eddb43b8b1e179bef87d41d'), 'name' : 'Album1' } { '_id' : ObjectId('5eddbaab9fd7d3ec78b2fd8f'), 'name' : 'Album2' } > db.song.find().pretty() ## output { '_id' : ObjectId('5eddb74b0177c8f096d880ec'), 'title' : 'Song1', 'rating' : 9, 'album' : ObjectId('5eddbaab9fd7d3ec78b2fd8f') }
Ve výstupu druhého dotazu ve výše uvedeném fragmentu si všimněte aktualizovaného pole alba v dokumentu Song1.
Nyní smažeme dokumenty ve sbírkách alb i skladeb. K odebrání záznamů použijte níže uvedený kód. Pokud jste stále v baňce, použijte níže uvedené příkazy k odstranění dokumentu a ověření odstranění.
>>> song1.delete() >>> songs_q = Song.objects(title='Song1') >>> songs_q.count() 0 >>>
K odstranění dokumentu ze sbírky skladeb používáme metodu odstranění skladby song1. Mohli jsme provádět všechny základní operace CRUD pomocí baňkového pláště. Dále můžeme použít třídu ModelView flask_appbuilder k zobrazení databázových modelů jako pohledů.
Vytvořte pohledy založené na modelu, jak je znázorněno v níže uvedeném kódu.
from app.models import Album, Song from flask_appbuilder import ModelView from flask_appbuilder.models.mongoengine.interface import MongoEngineInterface class SongsView(ModelView): datamodel = MongoEngineInterface(Song) class AlbumView(ModelView): datamodel = MongoEngineInterface(Album)
Nejprve importujeme databázové modely spolu s ModelView a MongoEngineInterface. Potom podtřídíme ModelView a přiřadíme konkrétní instance MongoEngineInterface k atributu datového modelu našich pohledů.
Nyní zaregistrujme SongsView a AlbumView pomocí nabídky, jak je uvedeno níže, ve stejné kategorii.
appbuilder.add_view(AlbumView, 'Album View', category='Model Views') appbuilder.add_view(SongsView, 'Song View', category='Model Views')
Chcete-li získat přístup k těmto pohledům na aplikaci, přejděte na http: // localhost: 8080 /, přihlaste se do aplikace pomocí pověření správce a proveďte níže uvedené kroky, abyste pochopili výchozí zobrazení založená na modelu databáze.
Krok 1: Klikněte na nabídku Model View
Krok 2: Klikněte na podnabídku Zobrazení alba.
Krok 3: Kliknutím na ikonu plus vytvoříte dokument nebo záznam.
Krok 4: Zadejte název alba a uložte jej.
Podobně jako v předchozích krocích můžete pomocí těchto pohledů provádět všechny operace CRUD. Proto vytvořme skladbu pomocí podnabídky Zobrazení skladby, jak je znázorněno na následujícím obrázku. Všimněte si, jak je v rozevíracím seznamu zobrazeno referenční pole souvisejícího databázového modelu. Zkuste vytvořit další alba a skladby.
Stejné koncepty můžete dále prozkoumat pomocí MongoAlchemy; Další snadno použitelný a podobný ORM vytvořený pro snadný přístup k databázi MongoDB a manipulaci s ní pomocí Pythonu.
Zkontrolujte dokumentaci MongoAlchemy tady . Doporučujeme však vytvořit základní porozumění Flask-SQLAlchemy tím, že nejprve projdeme níže uvedenou část.
Flask Sqlite nebo Flask MySQL
V této části znovu použijeme stejnou aplikaci pro SQLAlchemy jako back-end engine. Proto prosím proveďte všechny dosud provedené změny a vytvořte samostatný tutoriál Git větev tutorial-3-sqla. Flask může používat SQLite a MySQL jako backendovou databázi. Doporučujeme používat SQLAlchemy jako ORM s těmito relačními databázemi.
Začněme se změnami, které musíme provést po vyzkoušení nové pobočky.
Konfigurace
Otevřete soubor config.py v kořenovém adresáři projektu a odeberte připojovací řetězec MongoDB. Aktualizujte soubor config.py připojovacím řetězcem pro Flask SQLite nebo Flask MySQL.
# The SQLAlchemy connection string. SQLALCHEMY_DATABASE_URI = 'sqlite:///' + os.path.join(basedir, 'app.db') # SQLALCHEMY_DATABASE_URI = 'mysql://myapp@localhost/myapp'
Aplikace __init__.py
Nyní otevřete soubor app / __ init__.py a vzdálené importy související s MongoEngine a importujte SQLA, jak je znázorněno níže.
#from flask_appbuilder.security.mongoengine.manager import SecurityManager from flask_appbuilder import AppBuilder, SQLA #from flask_mongoengine import MongoEngine # other lines of code #db = MongoEngine(app) db = SQLA(app) #appbuilder = AppBuilder(app, security_manager_class=SecurityManager) appbuilder = AppBuilder(app, db.session)
Baňkové modely
Aktualizujte models.py pomocí následujícího kódu a odeberte kód související s MongoEngine.
from flask_appbuilder import Model from sqlalchemy import Column, Integer, String, ForeignKey from sqlalchemy.orm import relationship
Pohledy na baňky
Aktualizujte views.py pomocí následujícího kódu.
from flask_appbuilder import ModelView from app.models import Album, Song class AlbumView(ModelView): datamodel = SQLAInterface(Album) class SongsView(ModelView): datamodel = SQLAInterface(Song) appbuilder.add_view(AlbumView, 'Album View', category='Model Views') appbuilder.add_view(SongsView, 'Song View', category='Model Views')
Všimněte si, že jsme použili stejnou třídu ModelView, nicméně jsme změnili MongoEngineInterface s SQLAInterface.
Chcete-li vytvořit tabulky a jejich odpovídající vztahy, provedeme níže uvedený příkaz k vytvoření databázových objektů.
flask fab create-db
Nezapomeňte, že jsme změnili back-end databáze. Proto použijte k vytvoření uživatele správce příkaz flask fab create-admin. Nyní spusťte vývojový server jako dříve; pomocí pythonu run.py. Přejděte na http: // localhost: 8080.
Tady v tomto okamžiku bude naše aplikace fungovat tak, jak fungovala v případě MongoDB. Vyzkoušejte to se všemi operacemi CRUD, jak jsme to udělali v předchozích částech.
Kromě toho jsme si při používání prohlížeče SQLite DB Browser ukázali obě odpovídající tabulky pro databázové modely.
Baňka MySQL
Chcete-li použít MySQL jako databázový backend, když používáme Flask-SQLAlchemy, musíme pouze aktualizovat jednu konfiguraci týkající se databáze v config.py.
SQLALCHEMY_DATABASE_URI = 'mysql://myapp@localhost/myapp'
Podle daného připojovacího řetězce je název databáze myapp. Uživatel pro připojení k databázi je myapp @ localhost. Oba jsou však předpoklady a měli bychom je vytvářet pomocí níže uvedených podrobností.
Proto použijte níže uvedené dotazy k vytvoření uživatele a databáze, aby fungovala databáze Flask MySQL ve vzájemném spojení. Proveďte tyto dotazy v klientu MySQL.
CREATE USER 'myapp'@'localhost' IDENTIFIED BY ''; GRANT ALL PRIVILEGES ON *.* TO 'myapp'@'localhost'; FLUSH PRIVILEGES; CREATE DATABASE myapp;
Musíme také nainstalovat Python3 mysqlclient. Nainstalujte vývojová záhlaví a knihovny, jak je uvedeno v níže uvedených příkazech.
sudo apt-get install python3-dev default-libmysqlclient-dev build-essential pip install mysqlclient
Nyní, protože jsme změnili databázový backend, musíme vytvořit tabulky odpovídající databázovým modelům. Musíme také vytvořit uživatele správce baňky, protože všechny registrované položky nabídky jsou chráněné a je k nim přístup pouze pro existujícího uživatele v aplikaci.
Tyto níže uvedené příkazy skryjí příkazy SQL nižší úrovně pro zrušení a vytvoření tabulek.
flask fab create-db flask fab create-admin
Po úspěšném dokončení všech výše uvedených kroků můžeme znovu přejít na http: // localhost: 8080. Nyní otevřete aplikaci, jak jsme ji získali v případě Flask SQLite.
Migrace baňky
Během počátečního vývoje aplikace existuje mnoho změn ve schématu databáze. Vývojáři, kteří zvyšují čas potřebný k vývoji, musí tyto změny provádět často. V takových podobných scénářích je plugin Flask-Migrate docela užitečný.
Nainstalujeme Flask-Migrate.
pip install flask-migrate
Po úspěšné instalaci je přidán dílčí příkaz db. Pomocí níže uvedeného kódu zkontrolujte obslužné programy příkazového řádku, které jsou přidány do tohoto dílčího příkazu db.
flask db --help
Nejprve musíme vytvořit objekt migrace, jak je ukázáno níže v app / __ init__.py.
from flask import Flask from flask_migrate import Migrate app = Flask(__name__) migrate = Migrate(app, db)
Zkusme některé příkazy s databází, kterou máme v naší aplikaci.
Inicializujte samostatné úložiště migrace.
flask db init
Podobně jako výše uvedené příkazy existují příkazy k vytvoření migrace a jejich použití pomocí příkazu pro upgrade. Tyto migrační příkazy použijeme jako součást pracovního postupu v našich dalších výukách, kdykoli to bude nutné.
Často kladené otázky
Můžete narazit na některé otázky týkající se používání databází s Flask.
Otázka 1) Jakou databázi Flask používá?
Odpovědět: Flask podporuje všechny databáze, které podporuje SQLAlchemy, což je databázová sada nástrojů pro Python, a je to ORM (Object Relation Mapper). Můžeme nainstalovat Flask-SQLAlchemy z PyPI pro práci s SQLAlchemy.
Flask-Alchemy je plugin Flask a vyžaduje kromě instalace minimální konfiguraci. Některé z převládajících databází, které vývojáři používají s Flask-SQLAlchemy, jsou SQLite, PostgreSQL, MySQL atd.
Flask má také pluginy jako Flask-MongoEngine, Flask-MongoAlchemy, Flask-CouchDB atd. Pro práci s databázemi založenými na dokumentech NoSQL, jako jsou MongoDB a CouchDB.
Otázka 2) Jak vytvořím databázi v baňce?
Odpovědět: Vytvoření databáze v baňce je obecně závislé na vzoru následovaném odpovídajícím pluginem baňky. Téměř všechny pluginy vytvářejí databáze na základě nastavení připojení k databázi definovaného v konfiguraci baňky v projektu.
Pokud však nepoužíváte plugin, můžete napsat vlastní metodu pro vytvoření databáze v Flasku.
Níže jsme uvedli triviální příklad vytvoření příkladu SQLite. Tento příklad používá g Object k udržení odkazu na připojení k databázi.
import sqlite3 from flask import g # g and current_app object current_app.config['DATABASE'] = 'MYDB' # Name of the database def get_db(): '''A method to get the database connection''' if 'db' not in g: g.db = sqlite3.connect( current_app.config['DATABASE'], detect_types=sqlite3.PARSE_DECLTYPES ) g.db.row_factory = sqlite3.Row return g.db def close_db(e=None): '''A method to close the database connection''' db = g.pop('db', None) if db is not None: db.close()
Otázka č. 3) Jak zobrazujete data z databáze v baňce?
Odpovědět: V baňce používají vývojáři různé mapovače relačních objektů, nazývané také ORM. Tyto ORM obecně mají API pro přístup k databázi pomocí atributu dotazu ke čtení dat z definovaného modelu databáze. Výsledky dotazů, které jsou uloženy v datových strukturách Pythonu, se zobrazují pomocí šablon Flask.
Při testování databázových modelů však lze výsledky vytisknout také na konzole v prostředí Flask Shell.
Jeden takový příklad dotazování na data pomocí API dotazů v Flask-SQLAlchemy je uveden níže.
>>> user1 = User.query.filter_by(username='testuser').first() >>> user1.id 2 >>> user1.email u'user1@example.org'
Závěr
V tomto kurzu jsme se zabývali koncepty souvisejícími s připojením k různým databázím pomocí stejného rozložení projektu. Odklonili jsme se od paradigmatu psaní nezpracovaných dotazů SQL uvnitř kódu.
Přístup k psaní tabulek ve formě modelů nás činí agilnějšími. Také jsme pokryli koncepty ukládání informací o databázi jako migrace. Migrace dále zvyšuje flexibilitu našeho vývojového pracovního postupu.
Dosud jsme pracovali na archetypu, který je automaticky generován tvůrcem aplikace Flask. V našich dalších tutoriálech v této sérii uděláme ještě jeden krok a probereme další Flaskové kotlové desky a koncepty práce s plány Flask.
=> Podívejte se na VŠECHNY návody pro baňky zde
Doporučené čtení
- Výukový program pro pythonovou baňku - Úvod do baňky pro začátečníky
- Výukový program pro flask API s příkladem | Rozšíření baňky pomocí API
- Aplikace baňky a rozložení projektu baňky s plánem a bootstrapem
- Top 31 populárních otázek na rozhovor s Python Flask s odpověďmi
- Top 10 databázových návrhových nástrojů pro vytváření komplexních datových modelů
- Výukový program pro vytváření databáze MongoDB
- MongoDB Vytvořit zálohu databáze