Ceci est une ancienne révision du document !
Doc de Flask-SQLAlchemy : https://flask-sqlalchemy.palletsprojects.com/en/3.0.x/
pip install flask-sqlalchemy
Ajouter les valeurs suivantes à l'objet config de l'application :
SQLALCHEMY_DATABASE_URI | URL de la base de données (voir formats ci-dessous) |
---|---|
SQLALCHEMY_TRACK_MODIFICATIONS | Mettre à False, sauf si on utilise les signaux |
Format pour l'URL de connexion :
SQLite (Linux, macOS) | sqlite:////absolute/path/to/database |
---|---|
SQLite (Windows) | sqlite:///c:/absolute/path/to/database |
Ajouter à config.py les lignes suivantes :
DB_PATH = os.path.join(DATA_PATH, 'db.sqlite') SQLALCHEMY_DATABASE_URI = 'sqlite:///' + DB_PATH SQLALCHEMY_TRACK_MODIFICATIONS = False
Source: https://stackoverflow.com/questions/53024891/modulenotfounderror-no-module-named-mysqldb
Installer le connecteur :
pip install pymysql
Format pour l'URL de connexion :
MySQL | mysql+pymysql://username:password@hostname/database |
---|
Ajouter à config.py les lignes suivantes :
DB_HOST = 'localhost' DB_NAME = 'exemple' DB_USER = 'toto' DB_PASSWORD = 'my-password-is-beautiful' SQLALCHEMY_DATABASE_URI = "mysql+pymysql://%s:%s@%s/%s" % (DB_USER, DB_PASSWORD, DB_HOST, DB_NAME) SQLALCHEMY_TRACK_MODIFICATIONS = False
Format pour l'URL de connexion :
Postgres | postgresql://username:password@hostname/database |
---|
…(à suivre)…
# Import des modules de Flask et de ses extensions from flask import Flask from flask_sqlalchemy import SQLAlchemy # Création de l'application et import de la configuration app = Flask(__name__) app.config.from_object('config') # Création de la DB db = SQLAlchemy(app) # Import et enregistrement des composants de l'application from app.controllers.admin import admin from app.controllers.auth import auth from app.controllers.main import main app.register_blueprint(admin) app.register_blueprint(auth) app.register_blueprint(main) # Import de modèles (si on en utilise dans le code qui suit) from app.models.user import User from app.models.role import Role # ...
Un modèle est une classe Python qui représente les enregistrements d'une table.
from app import db class Role(db.Model): __tablename__ = 'roles' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(64), unique=True) def __repr__(self): return '<Role %r>' % self.name
from app import db class User(db.Model): __tablename__ = 'users' id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(64), unique=True, index=True) email = db.Column(db.String(200), unique=True) def __repr__(self): return '<User %r>' % self.username def hello(self): print("Hello, my name is %s." % self.name)
Une clé primaire est obligatoire pour chaque table, elle est généralement appelée id.
Nom | Type Python | |
---|---|---|
Integer | int | Regular integer, typically 32 bits |
SmallInteger | int | Short-range integer, typically 16 bits |
BigInteger | int or long | Unlimited precision integer |
Float | float | Floating-point number |
Numeric | decimal.Decimal | Fixed-point number |
String | str | Variable-length string |
Text | str | Variable-length string, optimized for large or unbounded length |
Unicode | unicode | Variable-length Unicode string |
UnicodeText | unicode | Variable-length Unicode string, optimized for large or unbounded length |
Boolean | bool | Boolean value |
Date | datetime.date | Date value |
Time | datetime.time | Time value |
DateTime | datetime.datetime | Date and time value |
Interval | datetime.timedelta | Time interval |
Enum | str | List of string values |
PickleType | Any Python object | Automatic Pickle serialization |
LargeBinary | str | Binary blob |
primary_key | If set to True, the column is the table’s primary key. |
---|---|
unique | If set to True, do not allow duplicate values for this column. |
index | If set to True, create an index for this column, so that queries are more efficient. |
nullable | If set to True, allow empty values for this column. If set to False, the column will not allow null values. |
default | Define a default value for the column. |
One Role to Many Users :
class Role(db.Model): # ... # One role can have many users. users = db.relationship('User', backref='role') class User(db.Model): # ... # Each user has a role role_id = db.Column(db.Integer, db.ForeignKey('roles.id'))
Modèle Role : backref
ajoute un attribut role
au modèle User.
Modèle User : roles.id
identifie la colonne id
de la table roles
comme
“clé étrangère” dans la relation.
Flask shell permet d'interagir avec l'application, et notamment de manipuler les modèles, modifier des données, etc.
$ flask shell >>> from app import db >>> from app.models import User # création d'une instance >>> u = User() >>> u.name = 'Marc' >>> u.email = 'marc@email.com' # ajout dans la db >>> db.session.add(u) >>> db.session.commit() # modification >>> u.name = 'Marcounet' >>> db.session.commit()
Après avoir créé/modifié les modèles, il faut appliquer les changements dans la base de données (ajout de tables, création de champs, etc.)
Ne rien faire manuellement, mais utiliser les Migrations.
user = User.query.filter_by(name = 'Marc').one()