Menu

Flask Database Handling - Sådan bruges kolbe med en database

  • Vigtigste
  • Andet
  • Flask Database Handling - Sådan bruges kolbe med en database

flask database handling how use flask with database

Prøv Vores Instrument Til At Fjerne Problemer

I denne Flask-database tutorial lærer du at bruge Flask med forskellige databaser, såsom Flask MySQL, Flask MongoDB, SQLite osv.

Vi udvider de begreber, der er dækket af vores første Flask Python-tutorial. Vi starter med at bruge Flask med MongoDB, en dokumentbaseret NoSQL-database, hvor NoSQL står for ikke kun SQL.

Først dækker vi konceptet med at oprette forbindelse til databasen, og så fortæller vi dig, hvordan du ikke bliver låst med en database. Hvis det er nødvendigt, kan vi kun ændre konfigurationerne for at ændre database-backend.

=> Tjek den perfekte flaske træningsvejledning her

Sådan bruges kolbe med en database_

Hvad du lærer:

Flask Database Tutorial

I denne vejledning kan læsere tegne en sammenligning mellem de diskuterede databaser. Desuden taler vi om Flask-MongoEngine, Flask-SQLAlchemy og Flask MongoAlchemy. Disse to ORM'er, dvs. Object Relation Mapper, er ret populære.

ORM'er under emhætten oversætter objekterne (databasemodeller) transparent til databasekommandoer eller SQL-sætninger.

Fordelene ved at bruge en ORM er angivet nedenfor:

  1. Udviklere kan arbejde med objekter i stedet for tabeller og SQL.
  2. Brug Migrations til at holde styr på databaseopdateringer.
  3. Det reducerer udviklingsomkostninger og tid.
  4. Det overvinder databasespecifikke SQL-forskelle.

Ved brug af ORM'er behøver programmørerne ikke at skrive komplekse SQL-forespørgsler og kommandoer for at udføre basale SQL-kommandoer.

Opret forbindelse til databasen

Åbn konfigurationsfilen og læg mærke til nedenstående værdier. Flask-Appbuilder tager databaseoplysningerne om forbindelsesstrengen fra de nævnte værdier.

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

Alle funktioner på lavt niveau af databasestyring af ORM er blevet pakket ind under kommandoer Flask Click, som vi kan se ved hjælp af flaskefabrik - hjælp på kommandolinjen.

Kolbe MongoDB

I dette afsnit lærer vi, hvordan man bruger ORM'er i stedet for at bruge rå SQL-scripts til at arbejde med databaser i Flask.

MongoDB er en ikke-relationel dokumentbaseret database. Vi har allerede konfigureret det med vores aktuelle applikation til anvendelse af eksempel på kolbeundervisning.

Brug nedenstående kommandoer til at administrere MongoDB-serveren på den lokale maskine.

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

Vi har diskuteret to berømte ORM'er, som du kan bruge med MongoDB og Flask.

Ved hjælp af en databasedesigner oprettede vi to tabeller, der hedder Album og Song, og definerede et en-til-mange-forhold mellem Album og Song. Nedenfor er billedet, der viser det samme.

Kolbe MongoDB
Album- og sangforhold

Kolbe MongoEngine

Lad os nu oprette vores første MongoEngine DB-model.

Opret eller rediger filmodellerne.py under app-biblioteket, og tilføj 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 oprettet to MongoEngine-modeller kaldet Album og Song. Disse modeller svarer til de respektive dokumenter i MongoDB.

Albumet har et felt af typestreng med nogle begrænsninger.

  • Albumnavnet er unikt.
  • Albumnavnet kan ikke være tomt.
  • Albumnavnet kan maksimalt bestå af hundrede tegn.

Tilsvarende har dokumentets sang en titel, et vurderingsfelt og et referencefelt, der peger på et andet dokument, Album. Lad os gemme denne fil og oprette data ved hjælp af disse to modeller. Gå til projektets rodmappe, og brug kommandoen flask shell til at få adgang til kolbeapplikationen i Python shell.

Når du har indtastet skallen, skal du bruge nedenstående udsagn til at få adgang til MongoEngine-modellerne og oprette 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()

Lad os nu få adgang til databasen ved hjælp af Mongo-klienten og se, om data gemmes som et resultat af ovenstående udsagn. I ovenstående kode importerer vi først Album og Song og opretter derefter deres objekter med de krævede værdier for parametrene.

Her er parametre feltnavne som defineret i modellerne, og vi nævner vores data som værdier for disse parametre. Når oprettelsen af ​​objektet er vellykket, kalder vi lagringsmetoden på de respektive objekter for at gemme dokumenterne i databasen.

hvordan man åbner bin-filer på Windows 10

Brug mongo-kommandoen for at få adgang til MongoDB. Når du opretter forbindelse til serveren ved hjælp af mongo-klienten, skal du bruge nedenstående kommandoer.

# 1) Tjek listen over databaser

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

# 2) Brug vores database kaldet mydb

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

# 3) Tjek samlingerne a.k.a-tabeller i RDBMS

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

# 4) Angiv 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 arbejdet med Django, vil du indse, at MongoEngine fungerer meget lig Django's indbyggede ORM. I den sidste output, når vi forespurgte en sang, skal du bemærke, hvordan referencen til et andet dokument er for albumfeltet.

Lad os nu oprette endnu et album og udføre en opdatering af det eksisterende sangdokument.

>>> 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 modeller, dvs. album og sang. Opret derefter et nyt dokument kaldet album2. Forespørgselssamling i databasen, og få sangen ved hjælp af dens titel. Derefter får vi adgang til objektet ved hjælp af et matrixindeks over forespørgselsresultatet, opdateres ved hjælp af en tildelingsoperator og gemmer det opdaterede dokument.

Lad os nu bruge Mongo-klienten igen til at kontrollere de lagrede samlinger.

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

I output af den anden forespørgsel i ovenstående uddrag skal du bemærke det opdaterede albumfelt i Song1-dokumentet.

Lad os nu slette dokumenterne i både album- og sangsamling. Brug nedenstående kode til at fjerne posterne. Hvis du stadig er i flaskeskallen, skal du bruge nedenstående kommandoer til at slette et dokument og kontrollere sletningen.

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

Vi bruger sletningsmetoden på sang1 til at slette dokumentet fra sangsamlingen. Vi kunne udføre alle grundlæggende CRUD-operationer ved hjælp af en flaskeskal. Desuden kan vi bruge klassen ModelView af flask_appbuilder til at vise databasemodellerne som visninger.

Opret modelbaserede 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 databasemodellerne sammen med ModelView og MongoEngineInterface. Derefter underklasserer vi ModelView og tildeler bestemte MongoEngineInterface-forekomster til datamodelattributten for vores synspunkter.

Lad os nu registrere SongsView og AlbumView med menuen 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 at få adgang til disse visninger i applikationen skal du navigere til http: // localhost: 8080 /, logge ind i appen ved hjælp af administratorlegitimationsoplysningerne og udføre nedenstående trin for at forstå standarddatabasemodelbaserede visninger.

Trin 1: Klik på menuen Modelvisning

Modelvisningskategori som en menu
Modelvisningskategori som en menu

Trin 2: Klik på undermenuen Albumvisning.

Albumvisning som undermenu
Albumvisning som undermenu

Trin 3: Klik på plusikonet for at oprette et dokument eller en post.

Opret et dokument eller en post
Opret et dokument eller en post

Trin 4: Indtast navnet på albummet, og gem det.

ModelView_4

ModelView_5

I lighed med ovenstående trin kan du udføre alle CRUD-operationer ved hjælp af disse visninger. Lad os derfor oprette en sang ved hjælp af undermenuen Song View som vist på billedet nedenfor. Bemærk, hvordan et referencefelt for en relateret databasemodel vises i rullemenuen. Prøv at oprette nogle flere album og sange.

Opret en sang og henvis den til albummet
Opret en sang og henvis den til albummet

Du kan yderligere udforske de samme begreber ved hjælp af MongoAlchemy; En anden let at bruge og lignende ORM bygget til let MongoDB-databaseadgang og -manipulation ved hjælp af Python.

Se dokumentationen til MongoAlchemy her . Vi anbefaler dog at opbygge en grundlæggende forståelse af Flask-SQLAlchemy ved først at gennemgå nedenstående afsnit.

Kolbe Sqlite eller Kolbe MySQL

I dette afsnit anvender vi den samme applikation til SQLAlchemy som backendmotoren. Foretag derfor alle dine ændringer hidtil, og opret en separat Git-filtutorial-3-sqla. Kolben kan bruge SQLite og MySQL som en backend-database. Vi anbefaler, at du bruger SQLAlchemy som ORM med disse relationsdatabaser.

Lad os starte med de ændringer, vi skal foretage, når du tjekker en ny filial.

Konfig

Åbn config.py i projektets rodmappe, og fjern forbindelsesstrengen til MongoDB. Opdater config.py med forbindelsesstrengen til 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

Åbn nu app / __ init__.py-filen og fjern MongoEngine-relateret 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

Opdater models.py med følgende kode og fjern koden relateret til MongoEngine.

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

Kolbeudsigter

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

Bemærk, at vi har brugt den samme ModelView-klasse dog ændret MongoEngineInterface med SQLAInterface.

For at oprette tabellerne og deres tilsvarende forhold udfører vi nedenstående kommando for at oprette databaseobjekter.

flask fab create-db

Husk at vi har ændret database backend. Brug derfor kommandoen kolbe fab create-admin til at oprette admin-brugeren. Start nu udviklingsserveren som tidligere; ved hjælp af python run.py. Naviger til http: // localhost: 8080.

Her på dette tidspunkt fungerer vores ansøgning, som den fungerede i tilfælde af MongoDB. Test det med alle CRUD-operationer, som vi gjorde i de foregående afsnit.

Desuden har vi vist begge de tilsvarende tabeller til databasemodellerne, mens du bruger SQLite DB Browser.

SQLite Album-tabel
SQLite Album-tabel
Sqlite sangbord
Sqlite sangbord

Kolbe MySQL

For at bruge MySQL som database-backend, når vi bruger Flask-SQLAlchemy, behøver vi kun at opdatere en konfiguration vedrørende databasen i config.py.

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

I henhold til den givne forbindelsesstreng er navnet på databasen myapp. Brugeren til at oprette forbindelse til databasen er myapp @ localhost. Begge disse er dog forudsætninger, og vi skal oprette ved hjælp af nedenstående detaljer.

Brug derfor forespørgslerne nedenfor til at oprette en bruger og en database for at få Flask MySQL-databasen til at fungere sammen med hinanden. Udfør disse forespørgsler i MySQL-klienten.

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

Vi skal også installere Python3 mysqlclient. Installer udviklingsoverskrifter og biblioteker som angivet i nedenstående kommandoer.

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

Nu fordi vi har ændret database-backend, er vi nødt til at oprette tabeller svarende til databasemodellerne. Vi har også brug for at oprette en Flask admin-bruger, da alle de registrerede menupunkter er beskyttet og kun kan fås tilgås af en eksisterende bruger i applikationen.

Disse kommandoer nedenfor skjuler SQL-udsagnene på lavere niveau til at droppe og oprette tabellerne.

flask fab create-db flask fab create-admin

Efter en vellykket afslutning af alle ovenstående trin kan vi igen navigere til http: // localhost: 8080. Nu får du adgang til applikationen, som vi har fået i tilfælde af Flask SQLite.

Kolbe migrere

Under den tidlige udvikling af en applikation er der mange ændringer i skemaet til en database. Udviklere, der tilføjer et stort overhead til udviklingstiden, skal foretage disse ændringer ofte. I sådanne lignende scenarier er Flask-Migrate-pluginet ret nyttigt.

Lad os installere Flask-Migrate.

pip install flask-migrate

Efter vellykket installation tilføjes en db-underkommando. Kontroller kommandolinjeprogrammerne, der føjes til denne db-underkommando ved hjælp af nedenstående kode.

flask db --help

Først skal vi oprette et migreringsobjekt som vist nedenfor i app / __ init__.py.

forretningssystemanalytiker interview og spørgsmål
from flask import Flask from flask_migrate import Migrate app = Flask(__name__) migrate = Migrate(app, db)

Lad os prøve nogle kommandoer med den database, som vi har i vores applikation.

Initialiser et separat migrationsregister.

flask db init

I lighed med ovenstående kommandoer er der kommandoer til at oprette migreringer og anvende dem ved hjælp af opgraderingskommandoen. Vi bruger disse migreringskommandoer som en del af workflowet i vores efterfølgende tutorials, når det er nødvendigt.

Ofte stillede spørgsmål

Du kan komme på tværs af nogle af spørgsmålene relateret til brugen af ​​databaser med Flask.

Q # 1) Hvilken database bruger Flask?

Svar: Flask understøtter alle databaser, der understøttes af SQLAlchemy, som er et databaseværktøjssæt til Python og er en ORM (Object Relation Mapper). Vi kan installere Flask-SQLAlchemy fra PyPI for at arbejde med SQLAlchemy.

Flask-Alchemy er et Flask-plugin og kræver minimal konfiguration bortset fra installationen. Nogle af de udbredte databaser, som udviklere bruger med Flask-SQLAlchemy, er SQLite, PostgreSQL, MySQL osv.

Flask har også plugins som Flask-MongoEngine, Flask-MongoAlchemy, Flask-CouchDB osv. Til at arbejde med NoSQL-dokumentbaserede databaser som MongoDB og CouchDB.

Q # 2) Hvordan opretter jeg en database i Flask?

Svar: Oprettelsen af ​​en database i Flask afhænger generelt af mønsteret efterfulgt af det tilsvarende Flask-plugin. Næsten alle plugins opretter databaser baseret på de databaseforbindelsesindstillinger, der er defineret i Flask-konfigurationen i projektet.

Du kan dog skrive din egen metode til at oprette en database i Flask, når du ikke bruger et plugin.

Vi har givet et trivielt eksempel på oprettelse af et SQLite-eksempel nedenfor. Dette eksempel bruger g Object til at beholde referencen 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()

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

Svar: I Flask bruger udviklere forskellige Object Relational Mappers, også kaldet ORM. Disse ORM'er har generelt API'er til at få adgang til databasen ved hjælp af forespørgselsattributten til at læse dataene fra en defineret databasemodel. Resultater af forespørgsler, der er gemt i Pythons datastrukturer, vises ved hjælp af Flask Templates.

Under test af databasemodellerne kan resultaterne imidlertid også udskrives på konsollen i Flask Shell.

Et sådant eksempel på forespørgsel om data ved hjælp af forespørgsler API i Flask-SQLAlchemy er angivet nedenfor.

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

Konklusion

I denne vejledning dækkede vi koncepter relateret til forbindelse til forskellige databaser ved hjælp af det samme projektlayout. Vi flyttede væk fra paradigmet om at skrive rå SQL-forespørgsler inde i koden.

En tilgang til at skrive tabeller i form af modeller gør os mere adræt. Vi dækkede også begreberne lagring af databaseoplysninger som migrationer. Migrationer tilføjer yderligere fleksibilitet til vores udviklingsworkflow.

Indtil videre har vi arbejdet på en arketype, der automatisk genereres af Flask-appbyggeren. I vores næste tutorials i denne serie tager vi endnu et skridt og diskuterer de andre Flask-kedelplader og begreberne med at arbejde med Flask-tegninger.

=> Tjek ALLE kolbevejledninger her

Anbefalet læsning

^