Aproveitando o poder do Flask SQLAlchemy
O Flask SQLAlchemy é uma biblioteca poderosa e versátil que traz os benefícios do SQLAlchemy, uma ferramenta popular de Object-Relational Mapping (ORM), para o Flask, um framework web leve e flexível em Python . Essa combinação vencedora permite que os desenvolvedores integrem bancos de dados perfeitamente em seus aplicativos Flask, facilitando o gerenciamento de dados e a persistência.
Neste artigo, exploraremos os recursos e capacidades do Flask SQLAlchemy e nos aprofundaremos nas etapas necessárias para utilizá-lo efetivamente em seus projetos Flask.
Compreendendo o SQLAlchemy: a espinha dorsal do Flask SQLAlchemy
Antes de mergulhar no Flask SQLAlchemy, é importante compreender os fundamentos do SQLAlchemy. SQLAlchemy é um kit de ferramentas SQL abrangente e uma biblioteca de mapeamento objeto-relacional que fornece uma interface Python de alto nível para interagir com bancos de dados. Ele abstrai as complexidades das consultas SQL brutas e permite que os desenvolvedores interajam com bancos de dados usando objetos Python, tornando as operações de banco de dados mais intuitivas e eficientes.
O Flask SQLAlchemy se baseia no SQLAlchemy, estendendo seus recursos e integrando-se perfeitamente ao Flask. Ele fornece uma interface simplificada e funcionalidades adicionais especificamente adaptadas para aplicativos Flask. Com o Flask SQLAlchemy, você pode definir modelos de banco de dados como classes Python, executar operações de banco de dados usando métodos Python simples e aproveitar o poder dos recursos de consulta do SQLAlchemy.
Para integrar SQLAlchemy em seu aplicativo Flask, você pode usar Flask-SQLAlchemy, uma extensão Flask que adiciona suporte para SQLAlchemy. Usando o Flask-SQLAlchemy, você pode simplificar o processo de execução de operações de banco de dados em seu aplicativo Flask. Isso permitirá que você se concentre no desenvolvimento da lógica do aplicativo sem ter que se preocupar com as complexidades das consultas SQL.
O que é ORM (Mapeamento de relação de objeto)?
Se você estiver familiarizado com linguagens de programação, talvez saiba que elas são principalmente orientadas a objetos. No entanto, quando se trata de servidores de sistema de gerenciamento de banco de dados relacional (RDBMS), os dados são armazenados em tabelas. Para preencher essa lacuna, os desenvolvedores geralmente usam técnicas de mapeamento relacional de objeto (ORM), que envolvem o mapeamento de parâmetros de objeto para a estrutura de tabela RDBMS subjacente. Usando uma API ORM, você pode executar operações CRUD sem precisar escrever instruções SQL brutas.
Configurando o Flask SQLAlchemy: configuração e inicialização
Para começar a usar o Flask SQLAlchemy, o primeiro passo é definir as configurações necessárias e inicializar a extensão em seu aplicativo Flask. Isso envolve a instalação das dependências necessárias e a definição da string de conexão do banco de dados, que especifica o tipo, o local e as credenciais do banco de dados.
Depois que as dependências são instaladas e a string de conexão definida, o Flask SQLAlchemy pode ser inicializado criando uma instância da classe SQLAlchemy e associando-a ao seu aplicativo Flask. Isso permite que o Flask se comunique com o banco de dados e utilize os recursos fornecidos pelo Flask SQLAlchemy.
Nesta seção, vamos nos aprofundar nas técnicas de ORM usadas no Flask SQLAlchemy e criar um aplicativo da web simples. Ao entender como o Flask SQLAlchemy funciona, você poderá aproveitar sua funcionalidade ORM para interagir facilmente com seu banco de dados sem ter que escrever consultas SQL complexas.
Etapa 1 - Instale a extensão Flask SQLAlchemy .
pip install flask-sqlalchemy
Passo 2 − Para usar o SQLAlchemy em seu aplicativo Flask, é necessário importar a classe SQLAlchemy do módulo relevante.
from flask_sqlalchemy import SQLAlchemy
Etapa 3 - Em seguida, você deve criar uma instância de um objeto de aplicativo Flask e especificar o URI para o banco de dados que deseja usar.
app = Flask(__name__) app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///employees.sqlite3'
Passo 4 − Em seguida, instancie um objeto da classe SQLAlchemy, passando como parâmetro o objeto da aplicação Flask criado anteriormente. Este objeto inclui funções utilitárias para operações ORM, bem como uma classe base de modelo que pode ser usada para definir modelos definidos pelo usuário. No código de exemplo abaixo, um modelo de aluno é definido.
db = SQLAlchemy(app)
class Employees(db.Model):
id = db.Column('employee_id', db.Integer, primary_key = True)
name = db.Column(db.String(100))
city = db.Column(db.String(50))
addr = db.Column(db.String(200))
age = db.Column(db.String(3))
salary = db.Column(db.String(10))
def __init__(self, name, city, addr,age,salary):
self.name = name
self.city = city
self.addr = addr
self.age = age
self.salary = salary
Etapa 5 - Para criar ou usar o banco de dados especificado no URI, execute o método create_all() .
db.create_all()
O objeto Sessão SQLAlchemy é responsável por tratar todas as operações de persistência relacionadas aos objetos ORM.
As operações CRUD são executadas usando os métodos de sessão listados abaixo:
- db.session.add(model object) − Este método adiciona uma nova entrada na tabela que está vinculada ao objeto ORM.
- db.session.delete(model object) − Este método remove um registro da tabela.
- model.query.all() − Este método retorna todos os registros de uma tabela, semelhante à execução de uma consulta SELECT.
Para filtrar os registros recuperados na tabela de funcionários, você pode usar o atributo filter. Por exemplo, se você deseja recuperar registros com um valor de cidade ' California ', pode usar a seguinte instrução:
Employees.query.filter_by(city = ’California’).all()
Com tanto conhecimento, agora forneceremos funções de exibição para nosso aplicativo para adicionar dados de funcionários.
O ponto de entrada do aplicativo é a função display_all() vinculada à URL '/'. A tabela Conjunto de registros de funcionários é enviada como parâmetro para o modelo HTML. O código do lado do servidor no modelo renderiza os registros em formato de tabela HTML .
@app.route('/')
def display_all():
return render_template('display_all.html', employees = employees.query.all() )
O código HTML do modelo chamado ' display_all.html ' se parece com isso:
<!DOCTYPE html>
<html lang = "en">
<head></head>
<body>
<h3>
<a href = "{{ url_for('show_all') }}">Employees - Flask
SQLAlchemy example</a>
</h3>
<hr/>
{%- for message in get_flashed_messages() %}
{{ message }}
{%- endfor %}
<h3>Employees (<a href = "{{ url_for('newdata') }}">Add Employee
</a>)</h3>
<table>
<thead>
<tr>
<th>Name</th>
<th>City</th>
<th>Address</th>
<th>Age</th>
<th>Salary</th>
</tr>
</thead>
<tbody>
{% for employee in employees %}
<tr>
<td>{{ student.name }}</td>
<td>{{ student.city }}</td>
<td>{{ student.addr }}</td>
<td>{{ student.age }}</td>
<td>{{ student.salary }}</td>
</tr>
{% endfor %}
</tbody>
</table>
</body>
</html>
A página mencionada acima inclui um link para a URL mapeada para a função newdata() . Quando este link for clicado, ele abrirá um formulário para inserir as informações do funcionário.
Depois que o formulário é enviado, os dados são postados na mesma URL em um método POST.
código do arquivo newdata.html:
<!DOCTYPE html>
<html>
<body>
<h3>Employees - Flask SQLAlchemy example</h3>
<hr/>
{%- for category, message in get_flashed_messages(with_categories = true) %}
<div class = "alert alert-danger">
{{ message }}
</div>
{%- endfor %}
<form action = "{{ request.path }}" method = "post">
<label for = "name">Name</label><br>
<input type = "text" name = "name" placeholder = "Name" /><br>
<label for = "addr">Address</label><br>
<textarea name = "addr" placeholder = "addr"></textarea><br>
<label for = "city">City</label><br>
<input type = "text" name = "city" placeholder = "city" /><br>
<label for = "age">Age</label><br>
<input type = "text" name = "age" placeholder = "age" /><br>
<label for = "salary">Salary</label><br>
<input type = "text" name = "salary" placeholder = "salary" /><br>
<input type = "submit" value = "Submit" />
</form>
</body>
</html>
Se o método HTTP for identificado como POST, as informações enviadas por meio do formulário são inseridas na tabela de funcionários e o aplicativo redireciona de volta para a página inicial onde os dados adicionados são exibidos.
@app.route('/newdata', methods = ['GET', 'POST'])
def newdata():
if request.method == 'POST':
if not request.form['name'] or not request.form['city'] or not request.form['addr'] or not request.form['age'] or not request.form['salary']:
flash('Please enter all the fields', 'error')
else:
employee = employees(request.form['name'], request.form['city'],
request.form['addr'], request.form['age'], request.form['salary'])
db.session.add(employee)
db.session.commit()
flash('Record was successfully added')
return redirect(url_for('show_all'))
return render_template('newdata.html')
A seguir está o código completo para o aplicativo (main.py).
from flask import Flask, request, flash, url_for, redirect, render_template
from flask_sqlalchemy import SQLAlchemy
app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///employees.db'
app.config['SECRET_KEY'] = "random string"
db = SQLAlchemy(app)
class Employees(db.Model):
id = db.Column('employee_id', db.Integer, primary_key = True)
name = db.Column(db.String(100))
city = db.Column(db.String(50))
addr = db.Column(db.String(200))
age = db.Column(db.String(3))
salary = db.Column(db.String(10))
def __init__(self, name, city, addr, age, salary):
self.name = name
self.city = city
self.addr = addr
self.age = age
self.salary = salary
@app.route('/')
def display_all():
employees = Employees.query.all()
return render_template('display_all.html', employees=employees)
@app.route('/newdata', methods = ['GET', 'POST'])
def newdata():
if request.method == 'POST':
if not request.form['name'] or not request.form['city'] or not request.form['addr'] or not request.form['age'] or not request.form['salary']:
flash('Please enter all the fields', 'error')
else:
employee = Employees(request.form['name'], request.form['city'], request.form['addr'], request.form['age'], request.form['salary'])
db.session.add(employee)
db.session.commit()
flash('Record was successfully added')
return redirect(url_for('display_all'))
return render_template('newdata.html')
if __name__ == '__main__':
# db.create_all()
app.run(debug = True)
Execute o script no shell do Python e digite http://localhost:5000/ no navegador da web.
Clique no link 'Adicionar funcionário' para abrir um formulário para fornecer informações sobre o funcionário.
Preencha o formulário e clique no botão enviar. A página inicial será exibida novamente, mostrando as informações enviadas. A saída resultante é demonstrada abaixo.
Benefícios da Flask Sqlalchemy
- Ele usa ORM, o que significa que os desenvolvedores podem interagir com um banco de dados usando classes e métodos Python, facilitando a manipulação de dados sem a necessidade de escrever consultas SQL complexas.
- O Flask SQLAlchemy oferece suporte a vários back-ends de banco de dados, incluindo PostgreSQL, MySQL, SQLite e Oracle. Os desenvolvedores podem alternar facilmente entre back-ends de banco de dados sem alterar a base de código.
- O Flask SQLAlchemy pode lidar com aplicativos de grande escala com facilidade. Ele fornece uma interface de consulta poderosa que permite aos desenvolvedores escrever consultas complexas e realizar análises de dados com facilidade.
- O Flask SQLAlchemy fornece medidas de segurança integradas para proteger contra ataques de injeção de SQL, tornando-o uma maneira confiável e segura de trabalhar com bancos de dados.
- O Flask SQLAlchemy integra-se perfeitamente com outras extensões do Flask, facilitando a criação de aplicativos complexos com vários recursos.
Conclusão
Se você precisar integrar um banco de dados ao seu aplicativo da web Flask, poderá se beneficiar do uso do Flask SQLAlchemy. Ele permite que você mapeie facilmente objetos Python para tabelas de banco de dados relacionais e fornece uma interface amigável para consulta de dados. Além disso, ele se integra perfeitamente ao Flask, facilitando a instalação e a configuração. Ao usar Flask e SQLAlchemy juntos, você pode criar aplicativos da Web flexíveis e eficazes orientados a banco de dados.
