Meny

Flask Database Handling - Hvordan bruke kolbe med en database

  • Hoved
  • Annen
  • Flask Database Handling - Hvordan bruke kolbe med en database

flask database handling how use flask with database

Prøv Instrumentet Vårt For Å Eliminere Problemer

I denne Flask-databaseopplæringen kan du lære å bruke Flask med forskjellige databaser, for eksempel Flask MySQL, Flask MongoDB, SQLite, etc.

Vi utvider konseptene som dekkes i vår første Flask Python-opplæring. Vi starter med å bruke Flask med MongoDB, en dokumentbasert NoSQL-database, der NoSQL står for ikke bare SQL.

Først dekker vi konseptet med å koble til databasen, og så forteller vi deg hvordan du ikke kan bli låst med en database. Om nødvendig kan vi bare endre konfigurasjonene for å endre databasens backend.

=> Sjekk ut den perfekte flaskeopplæringsguiden her

Slik bruker du kolbe med en database_

Hva du vil lære:

Flask Database Tutorial

I denne opplæringen kan leserne trekke en sammenligning mellom de diskuterte databasene. Videre snakker vi om Flask-MongoEngine, Flask-SQLAlchemy og Flask MongoAlchemy. Disse to ORM-ene, dvs. Object Relation Mapper, er ganske populære.

ORMer under panseret oversetter objektene (databasemodeller) transparent til databasekommandoer eller SQL-setninger.

Fordelene ved å bruke en ORM er listet opp nedenfor:

  1. Utviklere kan jobbe med objekter i stedet for tabeller og SQL.
  2. Bruk Migrations for å holde oversikt over databaseoppdateringer.
  3. Det reduserer utviklingskostnader og tid.
  4. Den overvinner databasespesifikke SQL-forskjeller.

Når du bruker ORM, trenger ikke programmererne å skrive komplekse SQL-spørsmål og kommandoer for å utføre basale SQL-kommandoer.

Koble til databasen

Åpne konfigurasjonsfilen og legg merke til verdiene nedenfor. Flask-Appbuilder tar databasedetaljene på tilkoblingsstrengen fra de nevnte verdiene.

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

Alle funksjoner på lavt nivå av databaseadministrasjon av ORM har blitt pakket inn under Flask Click-kommandoer, som vi kan se ved hjelp av kolbe fab –help på kommandolinjen.

Kolbe MongoDB

I denne delen vil vi lære hvordan du bruker ORM-er i stedet for å bruke rå SQL-skript til å jobbe med databaser i Flask.

MongoDB er en ikke-relasjonell dokumentbasert database. Vi har allerede konfigurert det med vårt nåværende eksempel på applikasjon for kolbeopplæring.

Bruk kommandoene nedenfor for å administrere MongoDB-serveren på den lokale maskinen.

beste stedet å se kalt anime gratis
sudo systemctl start mongod # to start MongoDB sudo systemctl stop mongod # to stop MongoDB sudo systemctl status mongod # to check status MongoDB

Vi har diskutert to kjente ORM-er som du kan bruke med MongoDB og Flask.

Ved hjelp av en databasedesigner opprettet vi to tabeller kalt Album og sang og definerte et forhold mellom mange og album. Nedenfor er bildet som viser det samme.

Kolbe MongoDB
Album- og sangforhold

Kolbe MongoEngine

La oss nå lage vår første MongoEngine DB-modell.

Opprett eller rediger filmodellene.py under appkatalogen og legg til følgende kode.

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 laget to MongoEngine-modeller kalt Album og Song. Disse modellene tilsvarer de respektive dokumentene i MongoDB.

Albumet har ett felt av typestreng med noen begrensninger.

  • Albumnavnet er unikt.
  • Albumnavnet kan ikke være tomt.
  • Albumnavnet kan bestå av maksimalt hundre tegn.

På samme måte har dokumentsangen en tittel, et vurderingsfelt og et referansefelt som peker til et annet dokument, Album. La oss lagre denne filen og lage data ved hjelp av disse to modellene. Gå til prosjektets rotkatalog og bruk kommandoen flaskeskall for å få tilgang til kolbeapplikasjonen i Python-skall.

Når du har kommet inn i skallet, bruk utsagnene nedenfor for å få tilgang til MongoEngine-modellene og opprett eksempeldata som vist nedenfor.

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

La oss nå få tilgang til databasen ved hjelp av Mongo-klienten og se om data lagres som et resultat av uttalelsene gitt ovenfor. I koden ovenfor importerer vi først Album og Song, og lager deretter objektene deres med de nødvendige verdiene til parametrene.

Her er parametere feltnavn som definert i modellene, og vi nevner dataene våre som verdier for disse parametrene. Når opprettelsen av objektet er vellykket, kaller vi lagringsmetoden på de respektive objektene for å lagre dokumentene i databasen.

Bruk mongo-kommandoen for å få tilgang til MongoDB. Når du har koblet til serveren ved hjelp av Mongo-klienten, bruker du kommandoene nedenfor.

# 1) Sjekk listen over databaser

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

# 2) Bruk databasen vår som heter mydb

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

# 3) Sjekk samlingene a.k.a-tabeller i RDBMS

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

# 4) Oppfør et hvilket som helst dokument i albumsamlingen.

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

# 5) Skriv et hvilket som helst dokument i sangsamlingen.

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

Hvis du har jobbet med Django, vil du innse at MongoEngine fungerer veldig likt Djangos innebygde ORM. I den siste utgangen, når vi spurte en sang, legg merke til hvordan referansen til et annet dokument er for albumfeltet.

La oss nå lage et nytt album og utføre en oppdatering på det eksisterende sangdokumentet.

>>> 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 importerer begge modellene, dvs. album og sang. Opprett deretter et nytt dokument kalt album2. Query Song-samlingen i databasen og få sangen med tittelen. Deretter får vi tilgang til objektet ved hjelp av en matriseindeks av søkeresultatet, oppdaterer ved hjelp av en oppdragsoperatør og lagrer det oppdaterte dokumentet.

La oss nå bruke Mongo-klienten igjen for å sjekke de lagrede samlingene.

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

Legg merke til det oppdaterte albumfeltet i Song1-dokumentet i utgangen av det andre spørringen i utdraget ovenfor.

La oss nå slette dokumentene i både album og sangsamling. Bruk koden nedenfor for å fjerne postene. Hvis du fremdeles befinner deg i flaskeskallet, kan du bruke kommandoene nedenfor for å slette et dokument og bekrefte slettingen.

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

Vi bruker slettemetoden på sang1 for å slette dokumentet fra sangsamlingen. Vi kunne utføre alle grunnleggende CRUD-operasjoner ved hjelp av et kolbehus. Videre kan vi bruke ModelView-klassen til flask_appbuilder til å vise databasemodellene som visninger.

Lag modellbaserte visninger, som vist i koden nedenfor.

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 importerer først databasemodellene, sammen med ModelView og MongoEngineInterface. Deretter underklasserer vi ModelView og tilordner bestemte MongoEngineInterface-forekomster til datamodellattributtet til våre synspunkter.

La oss nå registrere SongsView og AlbumView med menyen som vist nedenfor under samme kategori.

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

For å få tilgang til disse visningene i applikasjonen, naviger til http: // localhost: 8080 /, logg deg på appen ved hjelp av administratorlegitimasjonen, og utfør trinnene nedenfor for å forstå standard databasemodellbaserte visninger.

Trinn 1: Klikk på Model View-menyen

Modellvisningskategori som en meny
Modellvisningskategori som en meny

Steg 2: Klikk på undermenyen Albumvisning.

Albumvisning som undermeny
Albumvisning som undermeny

Trinn 3: Klikk på pluss-ikonet for å opprette et dokument eller en post.

Lag et dokument eller en post
Lag et dokument eller en post

Trinn 4: Skriv inn navnet på albumet og lagre det.

ModelView_4

ModelView_5

I likhet med trinnene ovenfor kan du utføre alle CRUD-operasjoner ved hjelp av disse visningene. La oss derfor lage en sang ved hjelp av undermenyen Song View, som vist på bildet nedenfor. Legg merke til hvordan et referansefelt for en relatert databasemodell vises i rullegardinmenyen. Prøv å lage flere album og sanger.

Lag en sang og henvis den til albumet
Lag en sang og henvis den til albumet

Du kan videre utforske de samme konseptene ved hjelp av MongoAlchemy; En annen enkel å bruke, og lignende ORM bygget for enkel MongoDB-databasetilgang og manipulering ved hjelp av Python.

Vennligst sjekk dokumentasjonen til MongoAlchemy her . Vi anbefaler imidlertid å bygge en grunnleggende forståelse av Flask-SQLAlchemy ved å gå gjennom avsnittet nedenfor først.

Flask Sqlite eller Flask MySQL

I denne delen har vi den samme applikasjonen for SQLAlchemy som backendmotoren. Foreta derfor alle endringene dine så langt, og opprett en egen Git-grenopplæring-3-sqla. Flask kan bruke SQLite og MySQL som en backend-database. Vi anbefaler at du bruker SQLAlchemy som ORM med disse relasjonsdatabasene.

La oss starte med endringene vi trenger å gjøre etter at du har sjekket ut en ny gren.

Konfig

Åpne config.py i prosjektets rotkatalog og fjern tilkoblingsstrengen til MongoDB. Oppdater config.py med tilkoblingsstrengen for Flask SQLite eller Flask MySQL.

junit test case eksempel i java formørkelse
# The SQLAlchemy connection string. SQLALCHEMY_DATABASE_URI = 'sqlite:///' + os.path.join(basedir, 'app.db') # SQLALCHEMY_DATABASE_URI = 'mysql://myapp@localhost/myapp'

App __init__.py

Åpne nå app / __ init__.py-fil og ekstern MongoEngine-import, og importer SQLA som vist nedenfor.

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

Flaskemodeller

Oppdater models.py med følgende kode og fjern koden relatert til MongoEngine.

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

Kolbeutsikter

Oppdater views.py med følgende kode.

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

Merk at vi har brukt den samme ModelView-klassen, men endret MongoEngineInterface med SQLAInterface.

For å lage tabellene og deres tilhørende forhold, utfører vi kommandoen nedenfor for å lage databaseobjekter.

flask fab create-db

Husk at vi har endret database backend. Bruk derfor kommandoen kolbe fab create-admin til å opprette admin-brukeren. Start nå utviklingsserveren som tidligere; bruker python run.py. Naviger til http: // localhost: 8080.

Her på dette punktet vil søknaden vår fungere slik den fungerte i tilfelle MongoDB. Test det med alle CRUD-operasjoner, som vi gjorde i forrige avsnitt.

Videre har vi vist begge de tilsvarende tabellene for databasemodellene mens du bruker SQLite DB Browser.

SQLite Album-tabell
SQLite Album-tabell
Sqlite Sangbord
Sqlite Sangbord

Kolbe MySQL

For å bruke MySQL som database-backend, når vi bruker Flask-SQLAlchemy, trenger vi bare å oppdatere en konfigurasjon angående databasen i config.py.

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

I henhold til den gitte tilkoblingsstrengen er navnet på databasen myapp. Brukeren for å koble til databasen er myapp @ localhost. Begge disse er imidlertid forutsetninger, og vi bør lage ved hjelp av detaljene gitt nedenfor.

Bruk derfor spørsmålene nedenfor for å opprette en bruker og en database for å få Flask MySQL-databasen til å fungere sammen med hverandre. Utfør disse spørsmålene i MySQL-klienten.

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

Vi trenger også å installere Python3 mysqlclient. Installer utviklingshoder og biblioteker som angitt i kommandoene nedenfor.

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

Nå fordi vi har endret database-backend, må vi lage tabeller som tilsvarer databasemodellene. Vi trenger også å opprette en Flask admin-bruker ettersom alle de registrerte menyelementene er beskyttet og bare kan nås av en eksisterende bruker i applikasjonen.

Disse kommandoene nedenfor gjemmer SQL-setningene på lavere nivå for å slippe og lage tabellene.

flask fab create-db flask fab create-admin

Når alle trinnene ovenfor er fullført, kan vi igjen navigere til http: // localhost: 8080. Nå får du tilgang til applikasjonen slik vi fikk i tilfelle Flask SQLite.

Kolbe migrere

I løpet av den tidlige utviklingen av en applikasjon er det mange endringer i skjemaet til en database. Utviklere som legger til en ganske stor kostnad til utviklingstiden, må gjøre disse endringene ofte. I slike lignende scenarier er Flask-Migrate-plugin ganske nyttig.

La oss installere Flask-Migrate.

pip install flask-migrate

Ved vellykket installasjon legges en db-underkommando til. Sjekk kommandolinjeverktøyene som er lagt til denne db-underkommandoen ved å bruke koden nedenfor.

flask db --help

Først må vi opprette et migreringsobjekt, som vist nedenfor i app / __ init__.py.

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

La oss prøve noen kommandoer med databasen som vi har i applikasjonen vår.

Initialiser et eget migrasjonsregister.

flask db init

I likhet med ovennevnte kommandoer er det kommandoer for å opprette migrasjoner og bruke dem ved hjelp av oppgraderingskommandoen. Vi vil bruke disse overføringskommandoene som en del av arbeidsflyten i de påfølgende veiledningene når det er nødvendig.

ofte stilte spørsmål

Du kan komme over noen av spørsmålene knyttet til bruk av databaser med Flask.

Sp # 1) Hvilken database bruker Flask?

Svar: Flask støtter alle databaser som støttes av SQLAlchemy, som er en databaseverktøysett for Python, og er en ORM (Object Relation Mapper). Vi kan installere Flask-SQLAlchemy fra PyPI for å jobbe med SQLAlchemy.

Flask-Alchemy er et Flask-plugin og krever minimal konfigurasjon annet enn installasjonen. Noen av de vanlige databasene som utviklere bruker med Flask-SQLAlchemy er SQLite, PostgreSQL, MySQL, etc.

Flask har også plugins som Flask-MongoEngine, Flask-MongoAlchemy, Flask-CouchDB, etc. for å jobbe med NoSQL-dokumentbaserte databaser som MongoDB og CouchDB.

Spørsmål 2) Hvordan oppretter jeg en database i Flask?

Svar: Opprettelsen av en database i Flask er generelt avhengig av mønsteret etterfulgt av det tilsvarende Flask-pluginet. Nesten alle plugins oppretter databaser basert på databasetilkoblingsinnstillingene som er definert i Flask-konfigurasjonen i prosjektet.

Du kan imidlertid skrive din egen metode for å opprette en database i Flask når du ikke bruker et plugin.

Vi har gitt et trivielt eksempel på å lage et SQLite-eksempel nedenfor. Dette eksemplet bruker g Object for å beholde referansen til databaseforbindelsen.

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

Sp # 3) Hvordan viser du data fra en database i Flask?

Svar: I Flask bruker utviklere forskjellige Object Relational Mappers, også kalt ORM. Disse ORM-ene har vanligvis API-er for å få tilgang til databasen ved hjelp av spørre-attributtet for å lese dataene fra en definert databasemodell. Resultater av spørsmål som er lagret i Pythons datastrukturer vises ved hjelp av kolbamaler.

Imidlertid, mens du tester databasemodellene, kan resultatene også skrives ut på konsollen i Flask Shell.

Et slikt eksempel på spørring av data ved hjelp av API-spørsmålene i Flask-SQLAlchemy er gitt nedenfor.

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

Konklusjon

I denne veiledningen dekket vi konsepter relatert til å koble til forskjellige databaser ved hjelp av samme prosjektoppsett. Vi flyttet oss bort fra paradigmet om å skrive rå SQL-spørsmål inne i koden.

En tilnærming til å skrive tabeller i form av modeller gjør oss mer smidige. Vi dekket også begrepene lagring av databaseinformasjon som migrasjoner. Migrasjoner gir ytterligere mer fleksibilitet i utviklingsarbeidsflyten vår.

Så langt har vi jobbet med en arketype som automatisk genereres av Flask-appbyggeren. I våre neste opplæringsprogrammer i denne serien tar vi ett skritt til og diskuterer de andre Flask-kokeplatene og konseptene for å jobbe med Flask-tegninger.

=> Sjekk ALLE kolbeopplæringer her

Anbefalt lesing

^