Framework ORM Bases de données en Python en pratique

Ces dernières années, Python est devenu un langage de programmation efficace, facile à utiliser et flexible, et dans le domaine du développement Python, l'application du framework Databases ORM devient de plus en plus courante. Databases est un framework ORM simple, intuitif et léger qui prend en charge une variété de bases de données, notamment MySQL, PostgreSQL, SQLite et Microsoft SQL Server. Cet article vous présentera en détail le framework Databases et son application spécifique dans le développement Python.

1. Le concept de framework ORM

ORM signifie Object Relational Mapping. Il s'agit d'un mappage entre les tables de base de données relationnelles et les objets Python, de sorte que les développeurs n'ont plus besoin d'effectuer de programmation pendant le processus de programmation. et l'application du framework ORM dans Python offre aux développeurs plus de choix et rend le développement de programmes plus pratique.

2. Framework de bases de données

Databases est un framework ORM simple développé par le développeur Django ORM Andrew Goodwin. Sa plus grande caractéristique est qu'il est léger, pratique et facile à utiliser, et qu'il prend en charge une variété de bases de données, notamment MySQL et PostgreSQL. , SQLite et Microsoft SQL Server et d'autres types de bases de données.

1. Installer le framework Databases

Pour l'installation du framework Databases, vous pouvez utiliser pip pour l'installer. La commande est la suivante :

pip install databases==0.4.*

2. Connectez-vous à la base de données

Avant d'utiliser le framework Databases pour le développement. , vous devez d'abord vous connecter à la base de données. Les paramètres requis pour se connecter à la base de données incluent le type de base de données, le nom d'hôte, le nom de la base de données, le nom d'utilisateur et le mot de passe, etc. Dans ce développement, nous essayons de nous connecter à la base de données MySQL. Le code est le suivant :

import databases

DATABASE_URL = "mysql://user:password@hostname/database_name"

database = databases.Database(DATABASE_URL)

Ici, QAQsaaspassword est le mot de passe pour se connecter à la base de données, Askdnsadn312as est le nom d'utilisateur pour se connecter à la base de données, localhost est le nom d'hôte ou Adresse IP de la base de données et my_database est le nom de la base de données.

3. Créer des tables et des colonnes

Le framework de bases de données prend en charge le langage d'expression SQL pour créer des instructions de requête complexes, permettant aux développeurs de contrôler de manière plus flexible le processus d'exécution SQL. Dans le framework Databases, nous pouvons utiliser la classe Table pour créer des tables et la classe Column pour créer des colonnes.

Le code de création de la table est le suivant :

import sqlalchemy

metadata = sqlalchemy.MetaData()

users = sqlalchemy.Table(
    "users",
    metadata,
    sqlalchemy.Column("id", sqlalchemy.Integer, primary_key=True),
    sqlalchemy.Column("username", sqlalchemy.String),
    sqlalchemy.Column("password", sqlalchemy.String),
    sqlalchemy.Column("email", sqlalchemy.String),
)

Ici, nous utilisons l'objet MetaData dans SQLAlchemy et créons quatre champs (id, nom d'utilisateur, mot de passe et email) en définissant une table utilisateurs.

4. Exécuter des instructions SQL

Le framework de bases de données fournit également une méthode pour utiliser directement les instructions SQL pour fonctionner, ce qui est plus flexible. L'exécution des instructions SQL peut être réalisée via la méthode execute(). Le code est le suivant :

result = await database.execute(query)

où la requête représente le code de l'instruction SQL et le résultat est le résultat de l'exécution. Lorsque l'exécution est réussie, elle renvoie une liste composée. de type dict. Chaque dict représente un enregistrement dans les résultats de la requête SQL.

5. Utiliser ORM dans les bases de données

Le framework de bases de données prend également en charge ORM pour exécuter les instructions SQL, ce qui est plus pratique pour les développeurs. La méthode ORM permet de mapper les relations des objets avec la base de données, rendant le code plus lisible et maintenable.

En utilisant ORM, nous pouvons faire fonctionner la base de données en définissant un modèle. Le code est le suivant :

import sqlalchemy

metadata = sqlalchemy.MetaData()

users = sqlalchemy.Table(
    "users",
    metadata,
    sqlalchemy.Column("id", sqlalchemy.Integer, primary_key=True),
    sqlalchemy.Column("username", sqlalchemy.String),
    sqlalchemy.Column("password", sqlalchemy.String),
    sqlalchemy.Column("email", sqlalchemy.String),
)

class UserModel:
    id: int
    username: str
    password: str
    email: str

    __tablename__ = "users"

    query: sq.Select

    def __init__(self, **kwargs):
        for key, value in kwargs.items():
            setattr(self, key, value)

Ici, nous définissons une classe de modèle UserModel pour représenter notre objet table de données. Complétez la définition des tables et des colonnes dans SQLAlchemy, afin que l'ORM puisse être mappé à la base de données, ce qui est pratique, rapide et facile à maintenir.

3. Exemple d'application

Ici, nous prenons une simple application de blog comme exemple pour démontrer le fonctionnement spécifique du framework Databases.

1. Connectez-vous à la base de données

Les informations requises pour la connexion à la base de données sont également très simples, comme le montre le code suivant :

import databases

DATABASE_URL = "mysql://user:password@hostname/database_name"

database = databases.Database(DATABASE_URL)

L'URL DATABASE_URL spécifie ici divers paramètres de connexion à MySQL pour se connecter à notre système de base de données.

2. Définir le modèle

Dans cet exemple de blog, nous devons définir deux modèles de données. L'un est le modèle Blog, qui représente l'objet de publication de blog. Le code généré est le suivant :

class Blog:
    id: int
    title: str
    description: str
    content: str

    __tablename__ = "blog"

    query: sq.Select

    def __init__(self, **kwargs):
        for key, value in kwargs.items():
            setattr(self, key, value)

L'autre est l'utilisateur. model, qui représente l'objet utilisateur et génère Le code est le suivant :

class User:
    id: int
    name: str
    email: str
    password: str

    __tablename__ = "user"

    query: sq.Select

    def __init__(self, **kwargs):
        for key, value in kwargs.items():
            setattr(self, key, value)

De même, nous mappons son ORM à la base de données MySQL que nous connectons via une définition simple.

3. Créer une table

Étant donné que le système de base de données que nous utilisons est MySQL, nous devons créer la table correspondante :

CREATE TABLE `blog` (
  `id` int(11) unsigned NOT NULL AUTO_INCREMENT,
  `title` varchar(100) DEFAULT NULL,
  `description` varchar(100) DEFAULT NULL,
  `content` text,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

CREATE TABLE `user` (
  `id` int(11) unsigned NOT NULL AUTO_INCREMENT,
  `name` varchar(45) DEFAULT NULL,
  `email` varchar(100) DEFAULT NULL,
  `password` varchar(100) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

4.Insérer des données

Nous pouvons utiliser ORM pour saisir facilement des données. , le code généré est le suivant :

async def create_blog_post(title: str, description: str, content: str):
    query = blog.insert().values(title=title, description=description, content=content)
    return await database.execute(query)

async def create_user(name: str, email: str, password: str):
    query = user.insert().values(name=name, email=email, password=password)
    return await database.execute(query)

Ici, nous utilisons la méthode insert() pour terminer l'opération d'insertion de données, ce qui a une bonne lisibilité et permet aux développeurs de mieux maintenir le code.

5. Requête de données

Le framework de bases de données prend également en charge les opérations de requête, comme indiqué dans le code suivant :

async def get_blog_post(id: int):
    query = blog.select().where(blog.c.id == id)
    return await database.fetch_one(query)

async def get_all_users():
    query = user.select()
    return await database.fetch_all(query)

async def get_users_by_email(email: str):
    query = user.select().where(user.c.email == email)
    return await database.fetch_all(query)

Ici, nous utilisons la méthode select(), épissonnons les conditions pour obtenir un générateur et renvoyons un certain nombre de paires lors du parcours. . Nous pouvons également filtrer et trier les données à l'aide de données de requête.

Résumé

Le framework Databases est un framework ORM flexible, facile à utiliser et léger pour les développeurs Python. Il peut facilement prendre en charge une variété de bases de données et permettre aux développeurs de stocker, d'exploiter, de filtrer et de trier les données. Cet article démontre la flexibilité et la facilité d'utilisation du framework Databases, de la connexion à la base de données à la définition des opérations de modèle, en passant par les opérations d'insertion de données et de requête, permettant aux développeurs de développer plus efficacement des programmes Python.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!