flask database handling how use flask with database
In diesem Tutorial zur Flask-Datenbank lernen Sie, wie Sie Flask mit verschiedenen Datenbanken wie Flask MySQL, Flask MongoDB, SQLite usw. verwenden.
Wir werden die in unserem ersten Flask Python-Tutorial behandelten Konzepte erweitern. Wir beginnen mit der Verwendung von Flask mit MongoDB, einer dokumentbasierten NoSQL-Datenbank, in der NoSQL für Not Only SQL steht.
Zuerst behandeln wir das Konzept der Verbindung mit der Datenbank und dann lassen wir Sie wissen, wie Sie nicht mit einer Datenbank gesperrt werden. Bei Bedarf können wir nur die Konfigurationen ändern, um das Datenbank-Backend zu ändern.
=> Lesen Sie hier den Perfect Flask Training Guide
beste PC-Tuning-Software kostenlos
Was du lernen wirst:
Flask Database Tutorial
In diesem Tutorial können Leser einen Vergleich zwischen den besprochenen Datenbanken ziehen. Darüber hinaus sprechen wir über Flask-MongoEngine, Flask-SQLAlchemy und Flask MongoAlchemy. Diese beiden ORMs, d. H. Object Relation Mapper, sind sehr beliebt.
ORMs unter der Haube übersetzen die Objekte (Datenbankmodelle) transparent in Datenbankbefehle oder SQL-Anweisungen.
Die Vorteile der Verwendung eines ORM sind nachstehend aufgeführt:
- Entwickler können mit Objekten anstelle von Tabellen und SQL arbeiten.
- Verwenden Sie Migrationen, um Datenbankaktualisierungen zu verfolgen.
- Es reduziert Entwicklungskosten und Zeit.
- Es überwindet datenbankspezifische SQL-Unterschiede.
Bei Verwendung von ORMs müssen die Programmierer keine komplexen SQL-Abfragen und -Befehle schreiben, um Basis-SQL-Befehle auszuführen.
Verbindung zur Datenbank herstellen
Öffnen Sie die Konfigurationsdatei und beachten Sie die unten angegebenen Werte. Flask-Appbuilder übernimmt die Datenbankdetails der Verbindungszeichenfolge aus den genannten Werten.
# The MongoEngine connection string. MONGODB_SETTINGS = { 'DB': 'mydb', 'connect': False, }
Alle Funktionen der Datenbankverwaltung auf niedriger Ebene durch das ORM wurden unter Flask Click-Befehlen zusammengefasst, die mit flask fab –help in der Befehlszeile angezeigt werden.
Flasche MongoDB
In diesem Abschnitt erfahren Sie, wie Sie ORMs anstelle von SQL-Rohskripten für die Arbeit mit Datenbanken in Flask verwenden.
MongoDB ist eine nicht relationale dokumentbasierte Datenbank. Wir haben es bereits mit unserer aktuellen Beispielanwendung für das Kolben-Tutorial konfiguriert.
Verwenden Sie die unten angegebenen Befehle, um den MongoDB-Server auf dem lokalen Computer zu verwalten.
sudo systemctl start mongod # to start MongoDB sudo systemctl stop mongod # to stop MongoDB sudo systemctl status mongod # to check status MongoDB
Wir haben zwei berühmte ORMs besprochen, die Sie mit MongoDB und Flask verwenden können.
Mit einem Datenbankdesigner haben wir zwei Tabellen mit dem Namen Album und Song erstellt und eine Eins-zu-Viele-Beziehung zwischen Album und Song definiert. Unten ist das Bild dargestellt, das dasselbe darstellt.
Kolben MongoEngine
Jetzt erstellen wir unser erstes MongoEngine DB-Modell.
Erstellen oder bearbeiten Sie die Datei models.py im App-Verzeichnis und fügen Sie den folgenden Code hinzu.
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
Wir haben zwei MongoEngine-Modelle namens Album und Song erstellt. Diese Modelle entsprechen den jeweiligen Dokumenten in MongoDB.
Album hat ein Feld vom Typ Zeichenfolge mit einigen Einschränkungen.
- Der Albumname ist eindeutig.
- Der Albumname darf nicht leer sein.
- Der Albumname darf maximal hundert Zeichen lang sein.
Ebenso hat das Dokument Song einen Titel, ein Bewertungsfeld und ein Referenzfeld, das auf ein anderes Dokument, Album, verweist. Speichern Sie diese Datei und erstellen Sie Daten mit diesen beiden Modellen. Wechseln Sie in das Stammverzeichnis des Projekts und verwenden Sie den Befehl flask shell, um auf die flask-Anwendung in der Python-Shell zuzugreifen.
Verwenden Sie nach dem Aufrufen der Shell die folgenden Anweisungen, um auf die MongoEngine-Modelle zuzugreifen und Beispieldaten wie unten gezeigt zu erstellen.
>>> from app.models import Album, Song >>> album1 = Album(name='Album1') >>> album1.save() >>> song1 = Song(title='Song1', rating=9, album=album1) >>> song1.save()
Lassen Sie uns nun mit dem Mongo-Client auf die Datenbank zugreifen und sehen, ob Daten aufgrund der oben angegebenen Anweisungen gespeichert werden. Im obigen Code importieren wir zuerst Album und Song und erstellen dann ihre Objekte mit den erforderlichen Werten der Parameter.
Hier sind Parameter die Feldnamen, wie sie in den Modellen definiert sind, und wir erwähnen unsere Daten als Werte für diese Parameter. Sobald die Objekterstellung erfolgreich ist, rufen wir die Speichermethode für die jeweiligen Objekte auf, um die Dokumente in der Datenbank zu speichern.
Verwenden Sie den Befehl mongo, um auf MongoDB zuzugreifen. Wenn Sie mit dem Mongo-Client eine Verbindung zum Server hergestellt haben, verwenden Sie die folgenden Befehle.
# 1) Überprüfen Sie die Liste der Datenbanken
> show dbs #----- output ---- admin 0.000GB config 0.000GB local 0.000GB mydb 0.001GB #----- output ----
# 2) Verwenden Sie unsere Datenbank namens mydb
> use mydb #----- output ---- switched to db mydb #----- output ----
# 3) Überprüfen Sie die Sammlungen a.k.a Tabellen in RDBMS
> show collections #----- output ---- album permission permission_view role song user view_menu #----- output ----
# 4) Listen Sie ein beliebiges Dokument in der Albumsammlung auf.
> db.album.findOne() #----- output ---- { '_id' : ObjectId('5eddb43b8b1e179bef87d41d'), 'name' : 'Album1' } #----- output ----
# 5) Listen Sie ein beliebiges Dokument in der Liedersammlung auf.
> db.song.findOne() #----- output ---- { '_id' : ObjectId('5eddb74b0177c8f096d880ec'), 'title' : 'Song1', 'rating' : 9, 'album' : ObjectId('5eddb43b8b1e179bef87d41d') } #----- output ----
Wenn Sie mit Django gearbeitet haben, werden Sie feststellen, dass MongoEngine dem in Django integrierten ORM sehr ähnlich ist. Beachten Sie in der letzten Ausgabe, wenn wir einen Titel abfragen, wie die Referenz eines anderen Dokuments für das Albumfeld ist.
Jetzt erstellen wir ein weiteres Album und führen ein Update für das vorhandene Songdokument durch.
>>> 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()
Wir importieren beide Modelle, d. H. Album und Song. Erstellen Sie dann ein neues Dokument mit dem Namen album2. Fragen Sie die Songsammlung in der Datenbank ab und rufen Sie den Song anhand seines Titels ab. Anschließend greifen wir mithilfe eines Array-Index des Abfrageergebnisses auf das Objekt zu, aktualisieren es mithilfe eines Zuweisungsoperators und speichern das aktualisierte Dokument.
Verwenden Sie nun den Mongo-Client erneut, um die gespeicherten Sammlungen zu überprüfen.
> 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') }
Beachten Sie in der Ausgabe der zweiten Abfrage im obigen Snippet das aktualisierte Albumfeld des Song1-Dokuments.
Löschen wir nun die Dokumente in der Album- und Song-Sammlung. Verwenden Sie den folgenden Code, um die Datensätze zu entfernen. Wenn Sie sich noch in der Kolbenhülle befinden, löschen Sie mit den folgenden Befehlen ein Dokument und überprüfen Sie das Löschen.
>>> song1.delete() >>> songs_q = Song.objects(title='Song1') >>> songs_q.count() 0 >>>
Wir verwenden die Löschmethode für song1, um das Dokument aus der Song-Sammlung zu löschen. Wir könnten alle grundlegenden CRUD-Operationen mit einer Kolbenschale durchführen. Darüber hinaus können wir die ModelView-Klasse von flask_appbuilder verwenden, um die Datenbankmodelle als Ansichten anzuzeigen.
Erstellen Sie modellbasierte Ansichten, wie im folgenden Code gezeigt.
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)
Wir importieren zuerst die Datenbankmodelle zusammen mit ModelView und MongoEngineInterface. Anschließend unterteilen wir die ModelView in eine Unterklasse und weisen dem Datenmodellattribut unserer Ansichten bestimmte MongoEngineInterface-Instanzen zu.
Registrieren wir nun SongsView und AlbumView mit dem unten gezeigten Menü unter derselben Kategorie.
appbuilder.add_view(AlbumView, 'Album View', category='Model Views') appbuilder.add_view(SongsView, 'Song View', category='Model Views')
Um auf diese Ansichten in der Anwendung zuzugreifen, navigieren Sie zu http: // localhost: 8080 /, melden Sie sich mit den Administratoranmeldeinformationen bei der App an und führen Sie die folgenden Schritte aus, um die auf dem Datenbankmodell basierenden Standardansichten zu verstehen.
Schritt 1: Klicken Sie auf das Menü Modellansicht
Wie viele Dateitypen gibt es? Python
Schritt 2: Klicken Sie auf das Untermenü Albumansicht.
Schritt 3: Klicken Sie auf das Pluszeichen, um ein Dokument oder einen Datensatz zu erstellen.
Schritt 4: Geben Sie den Namen des Albums ein und speichern Sie es.
Ähnlich wie in den obigen Schritten können Sie mit diesen Ansichten alle CRUD-Operationen ausführen. Lassen Sie uns daher ein Lied über das Untermenü 'Songansicht' erstellen, wie im folgenden Bild gezeigt. Beachten Sie, wie ein Referenzfeld eines verwandten Datenbankmodells in der Dropdown-Liste angezeigt wird. Versuchen Sie, weitere Alben und Songs zu erstellen.
Mit MongoAlchemy können Sie dieselben Konzepte weiter untersuchen. Ein weiteres einfach zu verwendendes und ähnliches ORM, das für den einfachen Zugriff auf und die Bearbeitung von MongoDB-Datenbanken mit Python entwickelt wurde.
Bitte überprüfen Sie die Dokumentation von MongoAlchemy Hier . Wir empfehlen jedoch, ein grundlegendes Verständnis der Flask-SQLAlchemy aufzubauen, indem Sie zuerst den folgenden Abschnitt durchgehen.
Flask Sqlite oder Flask MySQL
In diesem Abschnitt verwenden wir dieselbe Anwendung für SQLAlchemy wie die Backend-Engine. Bitte übernehmen Sie daher alle Ihre bisherigen Änderungen und erstellen Sie ein separates Git-Zweig-Tutorial-3-sqla. Flask kann SQLite und MySQL als Backend-Datenbank verwenden. Wir empfehlen, dass Sie SQLAlchemy als ORM für diese relationalen Datenbanken verwenden.
Beginnen wir mit den Änderungen, die wir vornehmen müssen, nachdem Sie einen neuen Zweig ausgecheckt haben.
Konfig
Öffnen Sie config.py im Stammverzeichnis des Projekts und entfernen Sie die Verbindungszeichenfolge von MongoDB. Aktualisieren Sie die Datei config.py mit der Verbindungszeichenfolge für Flask SQLite oder Flask MySQL.
# The SQLAlchemy connection string. SQLALCHEMY_DATABASE_URI = 'sqlite:///' + os.path.join(basedir, 'app.db') # SQLALCHEMY_DATABASE_URI = 'mysql://myapp@localhost/myapp'
App __init__.py
Öffnen Sie nun die Datei app / __ init__.py und Remote-MongoEngine-bezogene Importe und importieren Sie SQLA wie unten gezeigt.
#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)
Kolbenmodelle
Aktualisieren Sie models.py mit dem folgenden Code und entfernen Sie den Code für MongoEngine.
from flask_appbuilder import Model from sqlalchemy import Column, Integer, String, ForeignKey from sqlalchemy.orm import relationship
Kolbenansichten
Aktualisieren Sie views.py mit dem folgenden Code.
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')
Beachten Sie, dass wir dieselbe ModelView-Klasse verwendet haben, jedoch MongoEngineInterface mit SQLAInterface geändert haben.
Um die Tabellen und ihre entsprechenden Beziehungen zu erstellen, führen wir den folgenden Befehl aus, um Datenbankobjekte zu erstellen.
flask fab create-db
Denken Sie daran, dass wir das Datenbank-Backend geändert haben. Verwenden Sie daher den Befehl flask fab create-admin, um den Administratorbenutzer zu erstellen. Starten Sie nun den Entwicklungsserver wie zuvor. mit python run.py. Navigieren Sie zu http: // localhost: 8080.
Hier funktioniert unsere Anwendung an dieser Stelle wie im Fall von MongoDB. Testen Sie es mit allen CRUD-Operationen, wie wir es in den vorherigen Abschnitten getan haben.
Darüber hinaus haben wir beide entsprechenden Tabellen für die Datenbankmodelle bei Verwendung des SQLite DB-Browsers angezeigt.
Flasche MySQL
Um MySQL als Datenbank-Backend zu verwenden, müssen wir bei Verwendung von Flask-SQLAlchemy nur eine Konfiguration bezüglich der Datenbank in der Datei config.py aktualisieren.
SQLALCHEMY_DATABASE_URI = 'mysql://myapp@localhost/myapp'
Gemäß der angegebenen Verbindungszeichenfolge lautet der Name der Datenbank myapp. Der Benutzer, der eine Verbindung mit der Datenbank herstellen soll, ist myapp @ localhost. Beides sind jedoch Voraussetzungen, und wir sollten anhand der unten angegebenen Details erstellen.
Verwenden Sie daher die unten angegebenen Abfragen, um einen Benutzer und eine Datenbank zu erstellen, damit die Flask MySQL-Datenbank zusammenarbeitet. Führen Sie diese Abfragen im MySQL-Client aus.
CREATE USER 'myapp'@'localhost' IDENTIFIED BY ''; GRANT ALL PRIVILEGES ON *.* TO 'myapp'@'localhost'; FLUSH PRIVILEGES; CREATE DATABASE myapp;
Wir müssen auch Python3 mysqlclient installieren. Installieren Sie Entwicklungsheader und -bibliotheken wie in den folgenden Befehlen angegeben.
sudo apt-get install python3-dev default-libmysqlclient-dev build-essential pip install mysqlclient
Da wir nun das Datenbank-Backend geändert haben, müssen wir Tabellen erstellen, die den Datenbankmodellen entsprechen. Wir müssen auch einen Flask-Administrator erstellen, da alle registrierten Menüelemente geschützt sind und nur von einem vorhandenen Benutzer in der Anwendung aufgerufen werden können.
Diese unten angegebenen Befehle verbergen die untergeordneten SQL-Anweisungen zum Löschen und Erstellen der Tabellen.
flask fab create-db flask fab create-admin
Nach erfolgreichem Abschluss aller oben genannten Schritte können wir erneut zu http: // localhost: 8080 navigieren. Greifen Sie nun auf die Anwendung zu, wie wir sie im Fall von Flask SQLite erhalten haben.
Flask Migrate
Während der frühen Entwicklung einer Anwendung gibt es viele Änderungen am Schema einer Datenbank. Entwickler, die die Entwicklungszeit erheblich verlängern, müssen diese Änderungen häufig vornehmen. In solchen ähnlichen Szenarien ist das Flask-Migrate-Plugin sehr hilfreich.
Lassen Sie uns Flask-Migrate installieren.
pip install flask-migrate
Bei erfolgreicher Installation wird ein Unterbefehl db hinzugefügt. Überprüfen Sie die Befehlszeilendienstprogramme, die diesem Unterbefehl db hinzugefügt wurden, mithilfe des unten angegebenen Codes.
flask db --help
Zuerst müssen wir ein Migrationsobjekt erstellen, wie unten in app / __ init__.py gezeigt.
from flask import Flask from flask_migrate import Migrate app = Flask(__name__) migrate = Migrate(app, db)
Versuchen wir einige Befehle mit der Datenbank, die wir in unserer Anwendung haben.
Initialisieren Sie ein separates Migrationsrepository.
flask db init
Ähnlich wie bei den obigen Befehlen gibt es Befehle zum Erstellen und Anwenden von Migrationen mit dem Befehl upgrade. Wir werden diese Migrationsbefehle bei Bedarf als Teil des Workflows in unseren nachfolgenden Tutorials verwenden.
Häufig gestellte Fragen
Möglicherweise stoßen Sie auf einige Fragen im Zusammenhang mit der Verwendung von Datenbanken mit Flask.
F # 1) Welche Datenbank verwendet Flask?
Antworten: Flask unterstützt alle Datenbanken, die von SQLAlchemy unterstützt werden, einem Datenbank-Toolkit für Python und einem ORM (Object Relation Mapper). Wir können Flask-SQLAlchemy von PyPI installieren, um mit SQLAlchemy zu arbeiten.
Flask-Alchemy ist ein Flask-Plugin und erfordert außer seiner Installation nur eine minimale Konfiguration. Einige der gängigen Datenbanken, die Entwickler mit Flask-SQLAlchemy verwenden, sind SQLite, PostgreSQL, MySQL usw.
Flask verfügt auch über Plugins wie Flask-MongoEngine, Flask-MongoAlchemy, Flask-CouchDB usw. für die Arbeit mit dokumentbasierten NoSQL-Datenbanken wie MongoDB und CouchDB.
Verwendung einer .bin-Datei
F # 2) Wie erstelle ich eine Datenbank in Flask?
Antworten: Die Erstellung einer Datenbank in Flask hängt im Allgemeinen vom Muster ab, dem das entsprechende Flask-Plugin folgt. Fast alle Plugins erstellen Datenbanken basierend auf den Datenbankverbindungseinstellungen, die in der Flask-Konfiguration im Projekt definiert sind.
Sie können jedoch Ihre eigene Methode schreiben, um eine Datenbank in Flask zu erstellen, wenn Sie kein Plugin verwenden.
Im Folgenden finden Sie ein einfaches Beispiel für die Erstellung eines SQLite-Beispiels. In diesem Beispiel wird g Object verwendet, um die Referenz der Datenbankverbindung beizubehalten.
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()
F # 3) Wie zeigen Sie Daten aus einer Datenbank in Flask an?
Antworten: In Flask verwenden Entwickler verschiedene objektrelationale Mapper, auch ORM genannt. Diese ORMs verfügen im Allgemeinen über APIs für den Zugriff auf die Datenbank mithilfe des Abfrageattributs, um die Daten aus einem definierten Datenbankmodell zu lesen. Ergebnisse von Abfragen, die in Pythons Datenstrukturen gespeichert sind, werden mithilfe von Flask Templates angezeigt.
Beim Testen der Datenbankmodelle können die Ergebnisse jedoch auch auf der Konsole in Flask Shell gedruckt werden.
Ein solches Beispiel für das Abfragen der Daten mithilfe der Abfrage-API in Flask-SQLAlchemy ist unten angegeben.
>>> user1 = User.query.filter_by(username='testuser').first() >>> user1.id 2 >>> user1.email u'user1@example.org'
Fazit
In diesem Tutorial haben wir Konzepte behandelt, die sich auf die Verbindung mit verschiedenen Datenbanken mit demselben Projektlayout beziehen. Wir haben uns vom Paradigma entfernt, rohe SQL-Abfragen in den Code zu schreiben.
Ein Ansatz zum Schreiben von Tabellen in Form von Modellen macht uns agiler. Wir haben auch die Konzepte zum Speichern von Datenbankinformationen als Migrationen behandelt. Migrationen erhöhen die Flexibilität unseres Entwicklungsworkflows.
Bisher haben wir an einem Archetyp gearbeitet, der vom Flask App Builder automatisch generiert wird. In unseren nächsten Tutorials in dieser Reihe gehen wir noch einen Schritt weiter und diskutieren die anderen Flask-Boilerplates und die Konzepte für die Arbeit mit Flask-Blaupausen.
=> Überprüfen Sie ALLE Kolben-Tutorials hier
Literatur-Empfehlungen
- Python Flask Tutorial - Einführung in Flask für Anfänger
- Flask API Tutorial mit Beispiel | Flasche mit APIs erweitern
- Flask App und Flask Project Layout mit Blueprint & Bootstrap
- Top 31 beliebte Python Flask Interview Fragen mit Antworten
- Top 10 Datenbank-Design-Tools zum Erstellen komplexer Datenmodelle
- MongoDB Tutorial zum Erstellen einer Datenbank
- MongoDB Datenbanksicherung erstellen