flask database handling how use flask with database
In questo tutorial sul database Flask, impara a usare Flask con vari database, come Flask MySQL, Flask MongoDB, SQLite, ecc.
Estenderemo i concetti trattati nel nostro primo tutorial Flask Python. Iniziamo utilizzando Flask con MongoDB, un database NoSQL basato su documenti, dove NoSQL sta per Not Only SQL.
Per prima cosa, copriamo il concetto di connessione con il database, quindi ti facciamo sapere come non rimanere bloccato con un database. Se richiesto, possiamo modificare solo le configurazioni per cambiare il backend del database.
=> Dai un'occhiata alla guida all'addestramento della boccetta perfetta qui
java come rimuovere un elemento da un array
Cosa imparerai:
Esercitazione sul database di Flask
In questo tutorial, i lettori possono tracciare un confronto tra i database discussi. Inoltre, parliamo di Flask-MongoEngine, Flask-SQLAlchemy e Flask MongoAlchemy. Questi due ORM, ovvero Object Relation Mapper, sono piuttosto popolari.
Gli ORM sotto il cofano traducono in modo trasparente gli oggetti (modelli di database) in comandi di database o istruzioni SQL.
I vantaggi dell'utilizzo di un ORM sono elencati di seguito:
- Gli sviluppatori possono lavorare con oggetti invece che con tabelle e SQL.
- Usa le migrazioni per tenere traccia degli aggiornamenti del database.
- Riduce i costi e i tempi di sviluppo.
- Supera le differenze SQL specifiche del database.
Quando si utilizzano ORM, i programmatori non devono scrivere query SQL complesse e comandi per eseguire comandi SQL di base.
Connetti al database
Apri il file di configurazione e osserva i valori indicati di seguito. Flask-Appbuilder prende i dettagli del database sulla stringa di connessione dai valori menzionati.
# The MongoEngine connection string. MONGODB_SETTINGS = { 'DB': 'mydb', 'connect': False, } Tutte le funzionalità di basso livello della gestione del database da parte dell'ORM sono state inserite nei comandi Flask Click, che possiamo vedere utilizzando flask fab –help sulla riga di comando.
Flask MongoDB
In questa sezione, impareremo come utilizzare gli ORM piuttosto che utilizzare script SQL non elaborati per lavorare con i database in Flask.
MongoDB è un database non relazionale basato su documenti. L'abbiamo già configurato con la nostra attuale applicazione di esempio del tutorial sul pallone.
Utilizza i comandi indicati di seguito per gestire il server MongoDB sulla macchina locale.
sudo systemctl start mongod # to start MongoDB sudo systemctl stop mongod # to stop MongoDB sudo systemctl status mongod # to check status MongoDBAbbiamo discusso di due famosi ORM che puoi utilizzare con MongoDB e Flask.
Utilizzando un database designer, abbiamo creato due tabelle chiamate Album e Song e abbiamo definito una relazione uno-a-molti tra Album e Song. Di seguito è riportata l'immagine raffigurante lo stesso.
Flask MongoEngine
Ora creiamo il nostro primo modello MongoEngine DB.
Crea o modifica il file models.py nella directory dell'app e aggiungi il codice seguente.
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.titleAbbiamo creato due modelli MongoEngine chiamati Album e Song. Questi modelli corrispondono ai rispettivi documenti in MongoDB.
L'album ha un campo di tipo stringa con alcuni vincoli.
- Il nome dell'album è univoco.
- Il nome dell'album non può essere lasciato vuoto.
- Il nome dell'album può contenere un massimo di cento caratteri.
Allo stesso modo, il documento Song ha un titolo, un campo di valutazione e un campo di riferimento che punta a un altro documento, Album. Salviamo questo file e creiamo i dati utilizzando questi due modelli. Vai alla directory principale del progetto e usa il comando flask shell per accedere all'applicazione flask nella shell Python.
Una volta entrati nella shell, utilizzare le istruzioni seguenti per accedere ai modelli MongoEngine e creare dati di esempio come mostrato di seguito.
>>> from app.models import Album, Song >>> album1 = Album(name='Album1') >>> album1.save() >>> song1 = Song(title='Song1', rating=9, album=album1) >>> song1.save()Ora accediamo al database utilizzando il client Mongo e vediamo se i dati vengono salvati come risultato delle dichiarazioni sopra riportate. Nel codice sopra, importiamo prima Album e Song, quindi creiamo i loro oggetti con i valori richiesti dei parametri.
Qui i parametri sono i nomi dei campi come definiti nei modelli e citiamo i nostri dati come valori per quei parametri. Una volta che la creazione dell'oggetto è andata a buon fine, chiamiamo il metodo di salvataggio sui rispettivi oggetti per salvare i documenti nel database.
Usa il comando mongo per accedere a MongoDB. Dopo esserti connesso al server utilizzando il client mongo, utilizza i comandi seguenti.
# 1) Controlla l'elenco dei database
> show dbs #----- output ---- admin 0.000GB config 0.000GB local 0.000GB mydb 0.001GB #----- output ----# 2) Usa il nostro database chiamato mydb
> use mydb #----- output ---- switched to db mydb #----- output ----# 3) Controlla le collezioni alias tabelle in RDBMS
> show collections #----- output ---- album permission permission_view role song user view_menu #----- output ----# 4) Elenca un documento qualsiasi nella raccolta di album.
> db.album.findOne() #----- output ---- { '_id' : ObjectId('5eddb43b8b1e179bef87d41d'), 'name' : 'Album1' } #----- output ----# 5) Elenca un documento qualsiasi nella raccolta di canzoni.
> db.song.findOne() #----- output ---- { '_id' : ObjectId('5eddb74b0177c8f096d880ec'), 'title' : 'Song1', 'rating' : 9, 'album' : ObjectId('5eddb43b8b1e179bef87d41d') } #----- output ----Se hai lavorato con Django, ti renderai conto che MongoEngine funziona in modo molto simile all'ORM integrato di Django. Nell'ultimo output, quando abbiamo interrogato una canzone, notate come il riferimento di un altro documento sia per il campo album.
Ora creiamo un altro album ed eseguiamo un aggiornamento sul documento del brano esistente.
>>> 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() Importiamo entrambi i modelli, ovvero Album e Song. Quindi crea un nuovo documento chiamato album2. Esegui query sulla raccolta di brani nel database e ottieni la canzone utilizzando il suo titolo. Quindi accediamo all'oggetto utilizzando un indice di matrice del risultato della query, aggiorniamo utilizzando un operatore di assegnazione e salviamo il documento aggiornato.
Ora utilizziamo di nuovo il client Mongo per controllare le raccolte archiviate.
> 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') }Nell'output della seconda query nello snippet precedente, nota il campo album aggiornato del documento Song1.
Ora eliminiamo i documenti sia nella raccolta di album che in quella di brani. Usa il codice seguente per rimuovere i record. Se sei ancora nella shell del flask, utilizza i comandi indicati di seguito per eliminare un documento e verificare l'eliminazione.
>>> song1.delete() >>> songs_q = Song.objects(title='Song1') >>> songs_q.count() 0 >>>Utilizziamo il metodo di eliminazione su song1 per eliminare il documento dalla raccolta di brani. Potremmo eseguire tutte le operazioni CRUD di base utilizzando un guscio di fiasco. Inoltre, possiamo usare la classe ModelView di flask_appbuilder per visualizzare i modelli di database come viste.
Crea viste basate sul modello, come mostrato nel codice seguente.
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)Per prima cosa importiamo i modelli di database, insieme a ModelView e MongoEngineInterface. Quindi sottoclassiamo ModelView e assegniamo particolari istanze di MongoEngineInterface all'attributo del modello di dati delle nostre viste.
Ora registriamo SongsView e AlbumView con il menu come mostrato di seguito nella stessa categoria.
appbuilder.add_view(AlbumView, 'Album View', category='Model Views') appbuilder.add_view(SongsView, 'Song View', category='Model Views')Per accedere a tali visualizzazioni sull'applicazione, accedere a http: // localhost: 8080 /, accedere all'app utilizzando le credenziali di amministratore ed eseguire i passaggi indicati di seguito per comprendere le visualizzazioni basate sul modello di database predefinito.
Passo 1: Fare clic sul menu Vista modello
Passo 2: Fare clic sul sottomenu Vista album.
Passaggio 3: Fare clic sull'icona più per creare un documento o un record.
Passaggio 4: Immettere il nome dell'album e salvarlo.
Analogamente ai passaggi precedenti, è possibile eseguire tutte le operazioni CRUD utilizzando queste visualizzazioni. Pertanto, creiamo una canzone usando il sottomenu Song View come mostrato nell'immagine sottostante. Si noti come un campo di riferimento di un modello di database correlato viene visualizzato nell'elenco a discesa. Prova a creare altri album e brani.
Puoi esplorare ulteriormente gli stessi concetti usando MongoAlchemy; Un altro ORM simile e facile da usare creato per un facile accesso e manipolazione al database MongoDB utilizzando Python.
Controlla la documentazione di MongoAlchemy Qui . Tuttavia, consigliamo di costruire una conoscenza di base di Flask-SQLAlchemy passando prima attraverso la sezione seguente.
Flask Sqlite o Flask MySQL
In questa sezione, riutilizziamo la stessa applicazione per SQLAlchemy del motore di backend. Pertanto, eseguire il commit di tutte le modifiche fino ad ora e creare un tutorial separato per il ramo Git-3-sqla. Flask può utilizzare SQLite e MySQL come database di backend. Si consiglia di utilizzare SQLAlchemy come ORM con questi database relazionali.
Cominciamo con le modifiche che dobbiamo apportare dopo aver verificato un nuovo ramo.
Config
Apri config.py nella directory principale del progetto e rimuovi la stringa di connessione di MongoDB. Aggiorna config.py con la stringa di connessione per Flask SQLite o 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
Ora apri il file app / __ init__.py e le importazioni remote relative a MongoEngine e importa SQLA come mostrato di seguito.
#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)Modelli di matracci
Aggiorna models.py con il codice seguente e rimuovi il codice relativo a MongoEngine.
from flask_appbuilder import Model from sqlalchemy import Column, Integer, String, ForeignKey from sqlalchemy.orm import relationshipViste del pallone
Aggiorna views.py con il codice seguente.
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')Si noti che abbiamo utilizzato la stessa classe ModelView, tuttavia modificato MongoEngineInterface con SQLAInterface.
Per creare le tabelle e le loro relazioni corrispondenti, eseguiamo il comando indicato di seguito per creare oggetti di database.
flask fab create-dbRicorda che abbiamo cambiato il backend del database. Pertanto, utilizzare il comando flask fab create-admin per creare l'utente admin. Ora avvia il server di sviluppo come prima; usando python run.py. Accedi a http: // localhost: 8080.
A questo punto, la nostra applicazione funzionerà come ha funzionato nel caso di MongoDB. Provalo con tutte le operazioni CRUD, come abbiamo fatto nelle sezioni precedenti.
Inoltre, abbiamo mostrato entrambe le tabelle corrispondenti per i modelli di database durante l'utilizzo di SQLite DB Browser.
Flask MySQL
Per utilizzare MySQL come database backend, quando usiamo Flask-SQLAlchemy, dobbiamo solo aggiornare una configurazione relativa al database nel config.py.
SQLALCHEMY_DATABASE_URI = 'mysql://myapp@localhost/myapp'Secondo la stringa di connessione fornita, il nome del database è myapp. L'utente che si connette al database è myapp @ localhost. Tuttavia, entrambi sono prerequisiti e dovremmo creare utilizzando i dettagli forniti di seguito.
Pertanto, utilizzare le query fornite di seguito per creare un utente e un database per far funzionare il database Flask MySQL insieme. Esegui queste query nel client MySQL.
CREATE USER 'myapp'@'localhost' IDENTIFIED BY ''; GRANT ALL PRIVILEGES ON *.* TO 'myapp'@'localhost'; FLUSH PRIVILEGES; CREATE DATABASE myapp;Abbiamo anche bisogno di installare Python3 mysqlclient. Installa le intestazioni di sviluppo e le librerie come indicato nei comandi seguenti.
sudo apt-get install python3-dev default-libmysqlclient-dev build-essential pip install mysqlclientOra, poiché abbiamo modificato il backend del database, dobbiamo creare tabelle corrispondenti ai modelli di database. È inoltre necessario creare un utente amministratore Flask poiché tutte le voci di menu registrate sono protette e sono accessibili solo da un utente esistente nell'applicazione.
Questi comandi forniti di seguito nascondono le istruzioni SQL di livello inferiore per l'eliminazione e la creazione delle tabelle.
flask fab create-db flask fab create-adminDopo aver completato con successo tutti i passaggi precedenti, possiamo nuovamente navigare su http: // localhost: 8080. Ora accedi all'applicazione come abbiamo ottenuto nel caso di Flask SQLite.
Flask Migrate
Durante lo sviluppo iniziale di un'applicazione, vengono apportate molte modifiche allo schema di un database. Gli sviluppatori che aggiungono un bel sovraccarico al tempo di sviluppo devono apportare queste modifiche frequentemente. In tali scenari simili, il plug-in Flask-Migrate è molto utile.
Installiamo Flask-Migrate.
pip install flask-migrateIn caso di installazione corretta, viene aggiunto un sottocomando db. Controllare le utilità della riga di comando aggiunte a questo sottocomando db utilizzando il codice indicato di seguito.
flask db --helpInnanzitutto, dobbiamo creare un oggetto di migrazione, come mostrato di seguito in app / __ init__.py.
from flask import Flask from flask_migrate import Migrate app = Flask(__name__) migrate = Migrate(app, db)Proviamo alcuni comandi con il database che abbiamo nella nostra applicazione.
Inizializza un repository di migrazione separato.
flask db initAnalogamente ai comandi precedenti, esistono comandi per creare migrazioni e applicarle utilizzando il comando upgrade. Useremo questi comandi di migrazione come parte del flusso di lavoro nelle nostre esercitazioni successive ogni volta che sarà necessario.
Domande frequenti
Potresti incontrare alcune delle domande relative all'uso dei database con Flask.
D # 1) Quale database utilizza Flask?
implementare un albero di ricerca binario in java
Risposta: Flask supporta tutti i database supportati da SQLAlchemy, che è un toolkit di database per Python, ed è un ORM (Object Relation Mapper). Possiamo installare Flask-SQLAlchemy da PyPI per lavorare con SQLAlchemy.
Flask-Alchemy è un plugin Flask e richiede una configurazione minima oltre alla sua installazione. Alcuni dei database prevalenti che gli sviluppatori utilizzano con Flask-SQLAlchemy sono SQLite, PostgreSQL, MySQL, ecc.
Flask ha anche plug-in come Flask-MongoEngine, Flask-MongoAlchemy, Flask-CouchDB, ecc. Per lavorare con database NoSQL basati su documenti come MongoDB e CouchDB.
D # 2) Come si crea un database in Flask?
Risposta: La creazione di un database in Flask dipende generalmente dal modello seguito dal plug-in Flask corrispondente. Quasi tutti i plugin creano database in base alle impostazioni di connessione del database definite nella configurazione Flask nel progetto.
Tuttavia, puoi scrivere il tuo metodo per creare un database in Flask quando non usi un plugin.
Di seguito abbiamo fornito un esempio banale della creazione di un esempio SQLite. Questo esempio utilizza g Object per mantenere il riferimento della connessione al database.
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()D # 3) Come si visualizzano i dati da un database in Flask?
Risposta: In Flask, gli sviluppatori utilizzano vari Object Relational Mapper, chiamati anche ORM. Questi ORM generalmente dispongono di API per accedere al database utilizzando l'attributo query per leggere i dati da un modello di database definito. I risultati delle query archiviate nelle strutture dati di Python vengono visualizzati con l'aiuto dei modelli Flask.
Tuttavia, durante il test dei modelli di database, i risultati possono essere stampati anche sulla console in Flask Shell.
Di seguito viene fornito uno di questi esempi di query sui dati utilizzando l'API delle query in Flask-SQLAlchemy.
>>> user1 = User.query.filter_by(username='testuser').first() >>> user1.id 2 >>> user1.email u'user1@example.org'Conclusione
In questo tutorial, abbiamo trattato i concetti relativi alla connessione a diversi database utilizzando lo stesso layout di progetto. Ci siamo allontanati dal paradigma di scrivere query SQL non elaborate all'interno del codice.
Un approccio alla scrittura di tabelle sotto forma di modelli ci rende più agili. Abbiamo anche trattato i concetti di archiviazione delle informazioni del database come migrazioni. Le migrazioni aggiungono ulteriore flessibilità al nostro flusso di lavoro di sviluppo.
Finora abbiamo lavorato su un archetipo generato automaticamente dal generatore di app Flask. Nei prossimi tutorial di questa serie, faremo un ulteriore passo e discuteremo gli altri boilerplate Flask e i concetti di lavorare con i progetti Flask.
=> Controlla TUTTI i tutorial Flask qui
Lettura consigliata
- Python Flask Tutorial - Introduzione a Flask per principianti
- Esercitazione sull'API Flask con esempio | Flask estensibile con API
- Flask App e layout del progetto Flask con Blueprint e Bootstrap
- Le 31 domande più popolari dell'intervista a Python Flask con risposte
- I 10 migliori strumenti di progettazione di database per creare modelli di dati complessi
- Tutorial sulla creazione di database di MongoDB
- MongoDB Crea backup del database