flask database handling how use flask with database
Neste tutorial de banco de dados Flask, aprenda a usar o Flask com vários bancos de dados, como Flask MySQL, Flask MongoDB, SQLite, etc.
Vamos estender os conceitos abordados em nosso primeiro tutorial Flask Python. Começamos usando Flask com MongoDB, um banco de dados NoSQL baseado em documentos, onde NoSQL significa Not Only SQL.
Primeiro, abordamos o conceito de conexão com o banco de dados e, em seguida, informamos como não ficar preso a um banco de dados. Se necessário, podemos modificar apenas as configurações para alterar o backend do banco de dados.
=> Confira o guia de treinamento do frasco perfeito aqui
O que você aprenderá:
Tutorial do Flask Database
Neste tutorial, os leitores podem fazer uma comparação entre os bancos de dados discutidos. Além disso, falamos sobre Flask-MongoEngine, Flask-SQLAlchemy e Flask MongoAlchemy. Esses dois ORMs, ou seja, Mapeador de relação de objeto, são bastante populares.
Os ORMs sob o capô traduzem de forma transparente os objetos (modelos de banco de dados) em comandos de banco de dados ou instruções SQL.
Os benefícios de usar um ORM estão listados abaixo:
- Os desenvolvedores podem trabalhar com objetos em vez de tabelas e SQL.
- Use migrações para manter um controle das atualizações do banco de dados.
- Reduz custos e tempo de desenvolvimento.
- Ele supera as diferenças SQL específicas do banco de dados.
Ao usar ORMs, os programadores não precisam escrever consultas e comandos SQL complexos para executar comandos SQL básicos.
Conecte-se ao banco de dados
Abra o arquivo de configuração e observe os valores mencionados abaixo. O Flask-Appbuilder obtém os detalhes do banco de dados na string de conexão dos valores mencionados.
# The MongoEngine connection string. MONGODB_SETTINGS = { 'DB': 'mydb', 'connect': False, } Todos os recursos de baixo nível de gerenciamento de banco de dados pelo ORM foram incluídos nos comandos Flask Click, que podemos ver usando flask fab –help na linha de comando.
Flask MongoDB
Nesta seção, aprenderemos como usar ORMs em vez de usar scripts SQL brutos para trabalhar com bancos de dados no Flask.
MongoDB é um banco de dados não relacional baseado em documentos. Já o configuramos com nosso aplicativo de exemplo de tutorial de frasco atual.
Use os comandos fornecidos a seguir para gerenciar o servidor MongoDB na máquina local.
sudo systemctl start mongod # to start MongoDB sudo systemctl stop mongod # to stop MongoDB sudo systemctl status mongod # to check status MongoDBDiscutimos dois ORMs famosos que você pode usar com MongoDB e Flask.
Usando um designer de banco de dados, criamos duas tabelas chamadas Álbum e Música e definimos uma relação um-para-muitos entre Álbum e Música. Dada a seguir é a imagem que descreve o mesmo.
diferença entre teste sit e uat
Flask MongoEngine
Agora vamos criar nosso primeiro modelo de banco de dados MongoEngine.
Crie ou edite o arquivo models.py no diretório do aplicativo e adicione o código a seguir.
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.titleCriamos dois modelos de MongoEngine chamados Album e Song. Esses modelos correspondem aos respectivos documentos no MongoDB.
O álbum tem um campo do tipo string com algumas restrições.
- O nome do álbum é único.
- O nome do álbum não pode ficar em branco.
- O nome do álbum pode ter no máximo cem caracteres.
Da mesma forma, o documento Song possui um título, um campo de classificação e um campo de referência que aponta para outro documento, Álbum. Vamos salvar este arquivo e criar dados usando esses dois modelos. Vá para o diretório raiz do projeto e use o comando flask shell para acessar o aplicativo flask no shell Python.
Depois de entrar no shell, use as instruções abaixo para acessar os modelos MongoEngine e criar dados de amostra como mostrado abaixo.
>>> from app.models import Album, Song >>> album1 = Album(name='Album1') >>> album1.save() >>> song1 = Song(title='Song1', rating=9, album=album1) >>> song1.save()Agora vamos acessar o banco de dados usando o cliente Mongo e ver se os dados são salvos como resultado das instruções fornecidas acima. No código acima, primeiro importamos Álbum e Música e, em seguida, criamos seus objetos com os valores necessários dos parâmetros.
Aqui, os parâmetros são os nomes dos campos conforme definidos nos modelos, e mencionamos nossos dados como valores para esses parâmetros. Assim que a criação do objeto for bem-sucedida, chamamos o método save nos respectivos objetos para salvar os documentos no banco de dados.
Use o comando mongo para acessar o MongoDB. Depois de se conectar ao servidor usando o cliente mongo, use os comandos abaixo.
# 1) Verifique a lista de bancos de dados
> show dbs #----- output ---- admin 0.000GB config 0.000GB local 0.000GB mydb 0.001GB #----- output ----# 2) Use nosso banco de dados chamado mydb
> use mydb #----- output ---- switched to db mydb #----- output ----# 3) Verifique as coleções de tabelas a.k.a no RDBMS
> show collections #----- output ---- album permission permission_view role song user view_menu #----- output ----# 4) Liste qualquer documento da coleção de álbuns.
> db.album.findOne() #----- output ---- { '_id' : ObjectId('5eddb43b8b1e179bef87d41d'), 'name' : 'Album1' } #----- output ----# 5) Liste qualquer documento na coleção de músicas.
> db.song.findOne() #----- output ---- { '_id' : ObjectId('5eddb74b0177c8f096d880ec'), 'title' : 'Song1', 'rating' : 9, 'album' : ObjectId('5eddb43b8b1e179bef87d41d') } #----- output ----Se você trabalhou com Django, perceberá que o MongoEngine funciona de forma muito semelhante ao ORM embutido do Django. Na última saída, quando consultamos uma música, observe como a referência de outro documento é para o campo álbum.
Agora vamos criar outro álbum e atualizar o documento de música existente.
>>> 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() Importamos os modelos, ou seja, Álbum e Música. Em seguida, crie um novo documento chamado album2. Consulte a coleção de músicas no banco de dados e obtenha a música usando seu título. Em seguida, acessamos o objeto usando um índice de array do resultado da consulta, atualizamos usando um operador de atribuição e salvamos o documento atualizado.
Agora vamos usar o cliente Mongo novamente para verificar as coleções armazenadas.
> 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') }Na saída da segunda consulta no trecho acima, observe o campo de álbum atualizado do documento Song1.
Agora vamos excluir os documentos da coleção do álbum e da música. Use o código abaixo para remover os registros. Se você ainda estiver no shell do frasco, use os comandos mencionados abaixo para excluir um documento e verificar a exclusão.
>>> song1.delete() >>> songs_q = Song.objects(title='Song1') >>> songs_q.count() 0 >>>Usamos o método delete na song1 para excluir o documento da coleção de músicas. Poderíamos realizar todas as operações CRUD básicas usando uma concha de frasco. Além disso, podemos usar a classe ModelView de flask_appbuilder para exibir os modelos de banco de dados como visualizações.
Crie vistas baseadas em modelo, conforme mostrado no código abaixo.
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)Primeiro importamos os modelos de banco de dados, junto com ModelView e MongoEngineInterface. Em seguida, criamos uma subclasse de ModelView e atribuímos instâncias específicas de MongoEngineInterface ao atributo de modelo de dados de nossas visualizações.
Agora vamos registrar SongsView e AlbumView com o menu conforme mostrado abaixo na mesma categoria.
appbuilder.add_view(AlbumView, 'Album View', category='Model Views') appbuilder.add_view(SongsView, 'Song View', category='Model Views')Para acessar essas visualizações no aplicativo, navegue até http: // localhost: 8080 /, faça login no aplicativo usando as credenciais de administrador e execute as etapas mencionadas abaixo para entender as visualizações padrão baseadas no modelo de banco de dados.
Passo 1: Clique no menu Model View
Passo 2: Clique no submenu Visualização do álbum.
Etapa 3: Clique no ícone de adição para criar um documento ou registro.
Passo 4: Digite o nome do álbum e salve-o.
Semelhante às etapas acima, você pode executar todas as operações CRUD usando essas visualizações. Portanto, vamos criar uma música usando o submenu Song View, conforme mostrado na imagem abaixo. Observe como um campo de referência de um modelo de banco de dados relacionado é exibido no menu suspenso. Tente criar mais álbuns e músicas.
Você pode explorar ainda mais os mesmos conceitos usando MongoAlchemy; Outro ORM fácil de usar e semelhante, construído para fácil acesso e manipulação do banco de dados MongoDB usando Python.
Por favor, verifique a documentação do MongoAlchemy aqui . No entanto, recomendamos a construção de uma compreensão básica do Flask-SQLAlchemy, passando primeiro pela seção abaixo.
Flask Sqlite ou Flask MySQL
Nesta seção, redirecionamos o mesmo aplicativo para SQLAlchemy como o mecanismo de back-end. Portanto, confirme todas as suas alterações até agora e crie um branch tutorial-3-sqla separado do Git. O Flask pode usar SQLite e MySQL como banco de dados de back-end. Recomendamos que você use SQLAlchemy como ORM com esses bancos de dados relacionais.
Vamos começar com as mudanças que precisamos fazer depois de verificar um novo branch.
Config
Abra config.py no diretório raiz do projeto e remova a string de conexão do MongoDB. Atualize o config.py com a string de conexão para Flask SQLite ou 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
Agora abra o arquivo app / __ init__.py e importações remotas relacionadas ao MongoEngine e importe o SQLA conforme mostrado abaixo.
#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)Modelos de frascos
Atualize models.py com o código a seguir e remova o código relacionado ao MongoEngine.
from flask_appbuilder import Model from sqlalchemy import Column, Integer, String, ForeignKey from sqlalchemy.orm import relationshipVistas de frasco
Atualize views.py com o código a seguir.
melhor software conversor de vídeo para windows 10
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')Observe que usamos a mesma classe ModelView, mas mudou MongoEngineInterface com SQLAInterface.
Para criar as tabelas e seus relacionamentos correspondentes, executamos o comando mencionado abaixo para criar objetos de banco de dados.
flask fab create-dbLembre-se de que alteramos o back-end do banco de dados. Portanto, use o comando flask fab create-admin para criar o usuário admin. Agora inicie o servidor de desenvolvimento como antes; usando python run.py. Navegue para http: // localhost: 8080.
Aqui, neste ponto, nosso aplicativo funcionará como funcionou no caso do MongoDB. Teste-o com todas as operações CRUD, como fizemos nas seções anteriores.
Além disso, mostramos as tabelas correspondentes para os modelos de banco de dados durante o uso do SQLite DB Browser.
Flask MySQL
Para usar o MySQL como back-end do banco de dados, quando usamos Flask-SQLAlchemy, precisamos apenas atualizar uma configuração referente ao banco de dados no config.py.
SQLALCHEMY_DATABASE_URI = 'mysql://myapp@localhost/myapp'De acordo com a string de conexão fornecida, o nome do banco de dados é myapp. O usuário para se conectar ao banco de dados é myapp @ localhost. No entanto, ambos são pré-requisitos e devemos criar usando os detalhes fornecidos abaixo.
Portanto, use as consultas fornecidas abaixo para criar um usuário e um banco de dados para fazer o banco de dados Flask MySQL funcionar em conjunto. Execute essas consultas no cliente MySQL.
CREATE USER 'myapp'@'localhost' IDENTIFIED BY ''; GRANT ALL PRIVILEGES ON *.* TO 'myapp'@'localhost'; FLUSH PRIVILEGES; CREATE DATABASE myapp;Também precisamos instalar o mysqlclient Python3. Instale cabeçalhos de desenvolvimento e bibliotecas conforme fornecido nos comandos abaixo.
sudo apt-get install python3-dev default-libmysqlclient-dev build-essential pip install mysqlclientAgora, como alteramos o backend do banco de dados, precisamos criar tabelas correspondentes aos modelos de banco de dados. Também precisamos criar um usuário administrador do Flask, pois todos os itens de menu registrados são protegidos e podem ser acessados apenas por um usuário existente no aplicativo.
Esses comandos fornecidos a seguir ocultam as instruções SQL de nível inferior para eliminar e criar as tabelas.
flask fab create-db flask fab create-adminApós a conclusão bem-sucedida de todas as etapas acima, podemos navegar novamente para http: // localhost: 8080. Agora acesse a aplicação como obtivemos no caso do Flask SQLite.
Flask Migrate
Durante o desenvolvimento inicial de um aplicativo, há muitas mudanças no esquema de um banco de dados. Os desenvolvedores que aumentam bastante o tempo de desenvolvimento precisam fazer essas alterações com frequência. Em tais cenários semelhantes, o plugin Flask-Migrate é bastante útil.
Vamos instalar o Flask-Migrate.
pip install flask-migrateNa instalação bem-sucedida, um subcomando db é adicionado. Verifique os utilitários de linha de comando adicionados a este subcomando db usando o código mencionado abaixo.
flask db --helpPrimeiro, precisamos criar um objeto migrate, conforme mostrado abaixo em app / __ init__.py.
from flask import Flask from flask_migrate import Migrate app = Flask(__name__) migrate = Migrate(app, db)Vamos tentar alguns comandos com o banco de dados que temos em nossa aplicação.
Inicialize um repositório de migração separado.
flask db initSemelhante aos comandos acima, existem comandos para criar migrações e aplicá-las usando o comando upgrade. Usaremos esses comandos de migração como parte do fluxo de trabalho em nossos tutoriais subsequentes sempre que necessário.
perguntas frequentes
Você pode se deparar com algumas das questões relacionadas ao uso de bancos de dados com o Flask.
P # 1) Qual banco de dados o Flask usa?
Responda: O Flask suporta todos os bancos de dados que são suportados pelo SQLAlchemy, que é um kit de ferramentas de banco de dados para Python e é um ORM (Mapeador de Relação de Objeto). Podemos instalar o Flask-SQLAlchemy do PyPI para trabalhar com o SQLAlchemy.
Flask-Alchemy é um plugin do Flask e requer configuração mínima além de sua instalação. Alguns dos bancos de dados predominantes que os desenvolvedores usam com Flask-SQLAlchemy são SQLite, PostgreSQL, MySQL, etc.
O Flask também possui plug-ins como Flask-MongoEngine, Flask-MongoAlchemy, Flask-CouchDB, etc. para trabalhar com bancos de dados baseados em documentos NoSQL, como MongoDB e CouchDB.
P # 2) Como faço para criar um banco de dados no Flask?
Responda: A criação de um banco de dados no Flask geralmente depende do padrão seguido pelo plugin do Flask correspondente. Quase todos os plug-ins criam bancos de dados com base nas configurações de conexão de banco de dados definidas na configuração do Flask no projeto.
No entanto, você pode escrever seu próprio método para criar um banco de dados no Flask quando não estiver usando um plugin.
Demos um exemplo trivial de criação de um exemplo SQLite abaixo. Este exemplo usa g Object para manter a referência da conexão do banco de dados.
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()P # 3) Como você exibe dados de um banco de dados no Flask?
Responda: No Flask, os desenvolvedores usam vários Mapeadores Object Relacionais, também chamados de ORM. Esses ORMs geralmente têm APIs para acessar o banco de dados usando o atributo query para ler os dados de um modelo de banco de dados definido. Os resultados das consultas que são armazenados nas estruturas de dados do Python são exibidos com a ajuda dos modelos do Flask.
No entanto, ao testar os modelos de banco de dados, os resultados também podem ser impressos no Console do Flask Shell.
Um exemplo de consulta de dados usando a API de consultas em Flask-SQLAlchemy é fornecido abaixo.
>>> user1 = User.query.filter_by(username='testuser').first() >>> user1.id 2 >>> user1.email u'user1@example.org'Conclusão
Neste tutorial, cobrimos conceitos relacionados à conexão com diferentes bancos de dados usando o mesmo layout de projeto. Afastamos o paradigma de escrever consultas SQL brutas dentro do código.
Uma abordagem para escrever tabelas na forma de modelos nos torna mais ágeis. Também cobrimos os conceitos de armazenamento de informações de banco de dados como migrações. As migrações adicionam ainda mais flexibilidade ao nosso fluxo de trabalho de desenvolvimento.
Até agora, trabalhamos em um arquétipo que é gerado automaticamente pelo construtor de aplicativos Flask. Em nossos próximos tutoriais desta série, damos mais um passo e discutimos os outros boilerplates do Flask e os conceitos de trabalhar com os blueprints do Flask.
=> Verifique TODOS os tutoriais do frasco aqui
Leitura recomendada
- Tutorial do Python Flask - introdução ao Flask para iniciantes
- Tutorial da API Flask com exemplo | Estendendo Flask com APIs
- Flask App e Flask Layout de projeto com Blueprint e Bootstrap
- As 31 principais perguntas populares da entrevista do frasco de Python com respostas
- Dez principais ferramentas de design de banco de dados para construir modelos de dados complexos
- MongoDB Create Database Tutorial
- MongoDB Criar Backup de Banco de Dados