Meny

Flask Database Handling - Hur man använder Flask med en databas

  • Huvud
  • Övrig
  • Flask Database Handling - Hur man använder Flask med en databas

flask database handling how use flask with database

Prova Vårt Instrument För Att Eliminera Problem

I denna Flask-databashandledning lär du dig att använda Flask med olika databaser, till exempel Flask MySQL, Flask MongoDB, SQLite, etc.

Vi kommer att utöka koncepten som omfattas av vår första Flask Python-handledning. Vi börjar med att använda Flask med MongoDB, en dokumentbaserad NoSQL-databas, där NoSQL står för inte bara SQL.

Först täcker vi konceptet att ansluta till databasen och sedan meddelar vi dig hur du inte låses med en databas. Om det behövs kan vi bara ändra konfigurationerna för att ändra databasens backend.

=> Kolla in den perfekta träningsguiden för kolvar här

Hur man använder kolven med en databas_

Vad du kommer att lära dig:

Flask Database Tutorial

I denna handledning kan läsare göra en jämförelse mellan de diskuterade databaserna. Dessutom pratar vi om Flask-MongoEngine, Flask-SQLAlchemy och Flask MongoAlchemy. Dessa två ORM, dvs. Object Relation Mapper, är ganska populära.

ORM under huven översätter objekten (databasmodeller) transparent till databaskommandon eller SQL-uttalanden.

Fördelarna med att använda en ORM listas nedan:

  1. Utvecklare kan arbeta med objekt istället för tabeller och SQL.
  2. Använd Migrations för att hålla koll på databasuppdateringar.
  3. Det minskar utvecklingskostnader och tid.
  4. Det löser databasspecifika SQL-skillnader.

När man använder ORM: er behöver programmerarna inte skriva komplexa SQL-frågor och kommandon för att utföra bas-SQL-kommandon.

Anslut till databasen

Öppna konfigurationsfilen och lägg märke till nedanstående värden. Flask-Appbuilder tar databasinformation om anslutningssträngen från de nämnda värdena.

# The MongoEngine connection string. MONGODB_SETTINGS = { 'DB': 'mydb', 'connect': False, }

Alla lågnivåfunktioner för databashantering av ORM har lindats under Flask Click-kommandon, som vi kan se med flaskfabrik - hjälp på kommandoraden.

Kolv MongoDB

I det här avsnittet lär vi oss hur man använder ORM istället för att använda rå SQL-skript för att arbeta med databaser i Flask.

MongoDB är en icke-relationell dokumentbaserad databas. Vi har redan konfigurerat det med vårt nuvarande exempel på applikation för kolvhandledning.

Använd kommandona nedan för att hantera MongoDB-servern på den lokala maskinen.

sudo systemctl start mongod # to start MongoDB sudo systemctl stop mongod # to stop MongoDB sudo systemctl status mongod # to check status MongoDB

Vi har diskuterat två berömda ORM: er som du kan använda med MongoDB och Flask.

Med hjälp av en databasdesigner skapade vi två tabeller som heter Album och Song och definierade en en-till-många relation mellan Album och Song. Nedan visas bilden som visar densamma.

Kolv MongoDB
Album- och sångförhållande

Kolv MongoEngine

Låt oss nu skapa vår första MongoEngine DB-modell.

vad används c ++ för idag

Skapa eller redigera filmodellerna.py under appkatalogen och lägg till följande kod.

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

Vi har skapat två MongoEngine-modeller som heter Album och Song. Dessa modeller motsvarar respektive dokument i MongoDB.

Albumet har ett fält av typsträng med vissa begränsningar.

  • Albumnamnet är unikt.
  • Albumnamnet kan inte vara tomt.
  • Albumnamnet kan innehålla högst hundra tecken.

På samma sätt har dokumentet Song en titel, ett betygsfält och ett referensfält som pekar på ett annat dokument, Album. Låt oss spara den här filen och skapa data med dessa två modeller. Gå till projektets rotkatalog och använd kommandot flaskhölje för att komma åt flaskapplikationen i Python-skal.

När du har angett skalet, använd nedanstående uttalanden för att komma åt MongoEngine-modellerna och skapa exempeldata som visas nedan.

>>> from app.models import Album, Song >>> album1 = Album(name='Album1') >>> album1.save() >>> song1 = Song(title='Song1', rating=9, album=album1) >>> song1.save()

Låt oss nu komma åt databasen med Mongo-klienten och se om data sparas till följd av ovanstående uttalanden. I ovanstående kod importerar vi först Album och Song och skapar sedan deras objekt med de parametrar som krävs.

Här är parametrar fältnamnen som definieras i modellerna, och vi nämner våra data som värden för dessa parametrar. När skapandet av objekt väl har lyckats kallar vi spara metoden på respektive objekt för att spara dokumenten i databasen.

Använd mongo-kommandot för att komma åt MongoDB. När du har anslutit till servern med mongoklienten använder du kommandona nedan.

# 1) Kontrollera listan över databaser

> show dbs #----- output ---- admin 0.000GB config 0.000GB local 0.000GB mydb 0.001GB #----- output ----

# 2) Använd vår databas som heter mydb

> use mydb #----- output ---- switched to db mydb #----- output ----

# 3) Kontrollera samlingen a.k.a-tabeller i RDBMS

> show collections #----- output ---- album permission permission_view role song user view_menu #----- output ----

# 4) Lista upp ett dokument i albumsamlingen.

> db.album.findOne() #----- output ---- { '_id' : ObjectId('5eddb43b8b1e179bef87d41d'), 'name' : 'Album1' } #----- output ----

# 5) Lista upp ett dokument i sångsamlingen.

> db.song.findOne() #----- output ---- { '_id' : ObjectId('5eddb74b0177c8f096d880ec'), 'title' : 'Song1', 'rating' : 9, 'album' : ObjectId('5eddb43b8b1e179bef87d41d') } #----- output ----

Om du har arbetat med Django kommer du att inse att MongoEngine fungerar väldigt lik Djangos inbyggda ORM. I den senaste utgången, när vi frågade en låt, märker du hur referensen till ett annat dokument är för albumfältet.

Nu ska vi skapa ett nytt album och utföra en uppdatering av det befintliga låtdokumentet.

>>> 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()

Vi importerar båda modellerna, dvs. Album och Song. Skapa sedan ett nytt dokument som heter album2. Fråga Song-samlingen i databasen och få låten med titeln. Sedan kommer vi åt objektet med hjälp av ett matrisindex för frågeresultatet, uppdaterar med en tilldelningsoperator och sparar det uppdaterade dokumentet.

Låt oss nu använda Mongo-klienten igen för att kontrollera lagrade samlingar.

> 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') }

Lägg märke till det uppdaterade albumfältet i Song1-dokumentet i utgången från den andra frågan i utdraget ovan.

Låt oss nu ta bort dokumenten i både album och sångsamling. Använd koden nedan för att ta bort posterna. Om du fortfarande befinner dig i kolvskalet, använd sedan kommandona nedan för att radera ett dokument och verifiera borttagningen.

>>> song1.delete() >>> songs_q = Song.objects(title='Song1') >>> songs_q.count() 0 >>>

Vi använder borttagningsmetoden på sång 1 för att ta bort dokumentet från sångsamlingen. Vi kunde utföra alla grundläggande CRUD-operationer med ett kolvskal. Dessutom kan vi använda ModelView-klassen för flask_appbuilder för att visa databasmodellerna som vyer.

Skapa modellbaserade vyer, som visas i koden nedan.

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)

Vi importerar först databasmodellerna tillsammans med ModelView och MongoEngineInterface. Sedan underklassar vi ModelView och tilldelar särskilda MongoEngineInterface-instanser till datamodellattributet för våra åsikter.

Låt oss nu registrera SongsView och AlbumView med menyn som visas nedan under samma kategori.

appbuilder.add_view(AlbumView, 'Album View', category='Model Views') appbuilder.add_view(SongsView, 'Song View', category='Model Views')

För att komma åt dessa vyer i applikationen, navigera till http: // localhost: 8080 /, logga in i appen med administratörsuppgifterna och utför nedanstående steg för att förstå standarddatabasmodellbaserade vyer.

Steg 1: Klicka på menyn Model View

Modellvy kategori som en meny
Modellvy kategori som en meny

Steg 2: Klicka på undermenyn Albumvy.

Albumvy som undermeny
Albumvy som undermeny

Steg 3: Klicka på plusikonen för att skapa ett dokument eller en post.

Skapa ett dokument eller en post
Skapa ett dokument eller en post

Steg 4: Ange namnet på albumet och spara det.

ModelView_4

ModelView_5

I likhet med stegen ovan kan du utföra alla CRUD-operationer med hjälp av dessa vyer. Låt oss därför skapa en låt med undermenyn Song View som visas i bilden nedan. Observera hur ett referensfält för en relaterad databasmodell visas i rullgardinsmenyn. Prova att skapa fler album och låtar.

Skapa en låt och hänvisa den till albumet
Skapa en låt och hänvisa den till albumet

Du kan vidare utforska samma begrepp med MongoAlchemy; En annan lättanvänd och liknande ORM byggd för enkel MongoDB-databasåtkomst och -manipulation med Python.

Kontrollera dokumentationen för MongoAlchemy här . Vi rekommenderar dock att du bygger en grundläggande förståelse för Flask-SQLAlchemy genom att gå igenom nedanstående avsnitt först.

Flask Sqlite eller Flask MySQL

I det här avsnittet använder vi samma applikation för SQLAlchemy som backendmotorn. Därför gör du alla dina ändringar hittills och skapar en separat Git gren tutorial-3-sqla. Flask kan använda SQLite och MySQL som en backend-databas. Vi rekommenderar att du använder SQLAlchemy som ORM med dessa relationsdatabaser.

Låt oss börja med de förändringar som vi behöver göra efter att du checkat ut en ny filial.

Konfig

Öppna config.py i projektets rotkatalog och ta bort anslutningssträngen för MongoDB. Uppdatera config.py med anslutningssträngen för Flask SQLite eller 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

Öppna nu app / __ init__.py-fil och fjärransluten MongoEngine-relaterad import och importera SQLA som visas nedan.

#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)

Kolvmodeller

Uppdatera models.py med följande kod och ta bort koden relaterad till MongoEngine.

from flask_appbuilder import Model from sqlalchemy import Column, Integer, String, ForeignKey from sqlalchemy.orm import relationship

Flaskvyer

Uppdatera views.py med följande kod.

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')

Observera att vi har använt samma ModelView-klass men ändrat MongoEngineInterface med SQLAInterface.

För att skapa tabellerna och motsvarande förhållanden kör vi kommandot nedan för att skapa databasobjekt.

junit test fall exempel i java förmörkelse
flask fab create-db

Kom ihåg att vi har ändrat databasens backend. Använd därför kommandot flask fab create-admin för att skapa adminanvändaren. Starta nu utvecklingsservern som tidigare; använder python run.py. Navigera till http: // localhost: 8080.

Här vid denna tidpunkt kommer vår applikation att fungera som den fungerade i fallet med MongoDB. Testa det med alla CRUD-operationer, som vi gjorde i föregående avsnitt.

Dessutom har vi visat båda motsvarande tabeller för databasmodellerna medan du använder SQLite DB Browser.

SQLite Album-tabell
SQLite Album-tabell
Sqlite Song-bord
Sqlite Song-bord

Flask MySQL

För att använda MySQL som databasbackend, när vi använder Flask-SQLAlchemy, behöver vi bara uppdatera en konfiguration angående databasen i config.py.

SQLALCHEMY_DATABASE_URI = 'mysql://myapp@localhost/myapp'

Enligt den givna anslutningssträngen är databasens namn myapp. Användaren att ansluta till databasen är myapp @ localhost. Båda dessa är dock förutsättningar, och vi bör skapa med informationen nedan.

Använd därför frågorna nedan för att skapa en användare och en databas för att få Flask MySQL-databasen att fungera tillsammans. Utför dessa frågor i MySQL-klienten.

CREATE USER 'myapp'@'localhost' IDENTIFIED BY ''; GRANT ALL PRIVILEGES ON *.* TO 'myapp'@'localhost'; FLUSH PRIVILEGES; CREATE DATABASE myapp;

Vi måste också installera Python3 mysqlclient. Installera utvecklingsrubriker och bibliotek enligt kommandona nedan.

sudo apt-get install python3-dev default-libmysqlclient-dev build-essential pip install mysqlclient

Nu eftersom vi har ändrat databasens backend måste vi skapa tabeller som motsvarar databasmodellerna. Vi måste också skapa en Flask admin-användare eftersom alla registrerade menyalternativ är skyddade och endast kan nås av en befintlig användare i applikationen.

Dessa kommandon nedan döljer SQL-uttalanden på lägre nivå för att släppa och skapa tabeller.

flask fab create-db flask fab create-admin

När alla stegen ovan har slutförts kan vi åter navigera till http: // localhost: 8080. Gå nu till applikationen som vi fick i fallet med Flask SQLite.

Kolvmigrera

Under den tidiga utvecklingen av en applikation finns det många ändringar i schemat för en databas. Utvecklare som lägger till ganska stora kostnader för utvecklingstiden måste göra dessa ändringar ofta. I sådana liknande scenarier är plugin-programmet Flask-Migrate ganska användbart.

Låt oss installera Flask-Migrate.

pip install flask-migrate

Vid en lyckad installation läggs en db-underkommando till. Kontrollera kommandoradsverktygen som läggs till i denna db-underkommando med hjälp av nedanstående kod.

flask db --help

Först måste vi skapa ett migreringsobjekt, som visas nedan i app / __ init__.py.

from flask import Flask from flask_migrate import Migrate app = Flask(__name__) migrate = Migrate(app, db)

Låt oss prova några kommandon med den databas som vi har i vår applikation.

Initiera ett separat migrationsförvar.

flask db init

På samma sätt som ovanstående kommandon finns det kommandon för att skapa migreringar och tillämpa dem med hjälp av uppgraderingskommandot. Vi kommer att använda dessa migreringskommandon som en del av arbetsflödet i våra efterföljande handledning när så krävs.

Vanliga frågor

Du kan stöta på några av frågorna relaterade till användningen av databaser med Flask.

F # 1) Vilken databas använder Flask?

Svar: Flask stöder alla databaser som stöds av SQLAlchemy, som är en databasverktygssats för Python och är en ORM (Object Relation Mapper). Vi kan installera Flask-SQLAlchemy från PyPI för att arbeta med SQLAlchemy.

Flask-Alchemy är ett Flask-plugin och kräver minimal konfiguration förutom dess installation. Några av de vanliga databaser som utvecklare använder med Flask-SQLAlchemy är SQLite, PostgreSQL, MySQL, etc.

Flask har också plugins som Flask-MongoEngine, Flask-MongoAlchemy, Flask-CouchDB, etc. för att arbeta med NoSQL-dokumentbaserade databaser som MongoDB och CouchDB.

F # 2) Hur skapar jag en databas i Flask?

Svar: Skapandet av en databas i Flask är i allmänhet beroende av mönstret följt av motsvarande Flask-plugin. Nästan alla plugins skapar databaser baserat på de databasanslutningsinställningar som definierats i flaskkonfigurationen i projektet.

Du kan dock skriva din egen metod för att skapa en databas i Flask när du inte använder ett plugin.

Vi har gett ett trivialt exempel på att skapa ett SQLite-exempel nedan. I det här exemplet används g Object för att behålla referensen för databasanslutningen.

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) Hur visar du data från en databas i Flask?

Svar: I Flask använder utvecklare olika Object Relational Mappers, även kallade ORM. Dessa ORM har vanligtvis API: er för att komma åt databasen med hjälp av frågeattributet för att läsa data från en definierad databasmodell. Resultat av frågor som lagras i Pythons datastrukturer visas med hjälp av kolvmallar.

När du testar databasmodellerna kan resultaten dock skrivas ut på konsolen i Flask Shell.

Ett sådant exempel på att fråga data med hjälp av frågan API i Flask-SQLAlchemy ges nedan.

>>> user1 = User.query.filter_by(username='testuser').first() >>> user1.id 2 >>> user1.email u'user1@example.org'

Slutsats

I denna handledning behandlade vi begrepp relaterade till anslutning till olika databaser med samma projektlayout. Vi gick bort från paradigmet att skriva råa SQL-frågor inuti koden.

En metod för att skriva tabeller i form av modeller gör oss mer smidiga. Vi täckte också begreppen lagring av databasinformation som migrering. Migrationer ger ytterligare flexibilitet i vårt utvecklingsarbetsflöde.

Hittills har vi arbetat med en arketyp som genereras automatiskt av Flask-appbyggaren. I våra nästa självstudier i denna serie tar vi ytterligare ett steg och diskuterar de andra flaskpannorna och begreppen att arbeta med flaskritningar.

=> Kontrollera ALLA kolvstudier här

Rekommenderad läsning

^