Une brève introduction à SQLAlchemy sous Python

Ce que cet article vous apporte est une explication détaillée de la mise en œuvre de la synergie PHP (avec du code). Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer.

SQLAlchemy est un logiciel open source sous le langage de programmation Python. Fournit une boîte à outils SQL et des outils de mappage objet-relationnel (ORM), SQLAlchemy est publié sous la licence MIT. Il implémente un modèle de persistance complet de niveau entreprise utilisant un langage Python simple, conçu pour un accès efficace et performant aux bases de données. SQLAlchemy accorde une grande attention à la taille et aux performances de la base de données.

Cette section analyse l'utilisation de SQLAlchemy à travers un ensemble d'exemples.

L'utilisation de SQLAlchemy nécessite au moins 3 parties de code, qui doivent définir des tables, définir des connexions à la base de données et effectuer des opérations logiques telles que l'ajout, la suppression, la modification et l'interrogation.

Instance de la table de définition :

from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column,Integer,String
Base=declarative_base()
class Accout(Base):
    __tablename__=u'accout'
    id=Column(Integer,primary_key=True)
    user_namr=Column(String(50),nullable=False)
    password=Column(String(200),nullable=False)
    title=Column(String(50))
    salary=Column(Integer)

    def is_active(self):
        #假设所有
        return True

    def get_id(self):
        #返回账号ID，用方法返回属性值提高了表的封装性。
        return self.id

    def is_authenticated(self):
        #假设已经通过验证
        return True

    def is_anonymous(self):
        #具有登陆名和密码的账号不是匿名用户
        return False

Le code pour analyser la table de définition est le suivant :

• SQLAlchemy La table doit être utilisée avant d'introduire sqlalchemy.ext.declarative_base et d'en définir une instance de base. Toutes les tables doivent hériter de Base. Dans cet exemple, une classe de table de comptes Account est définie.

• définit le nom réel du compte de la table dans la base de données via l'attribut __tablename__.

• Introduisez les types Column, Integer et String dans le package sqlalchemy car ils doivent être utilisés pour définir les colonnes du tableau. Cet exemple définit cinq colonnes dans la table Account, à savoir l'identifiant et le salaire entiers, ainsi que les types de chaîne nom_utilisateur, mot de passe et titre.

• Vous pouvez définir des contraintes en passant des paramètres à Column lors de la définition des colonnes. Dans cet exemple, le paramètre Primary_key est utilisé pour définir la colonne id comme clé primaire, et le paramètre nullable est utilisé pour définir le nom d'utilisateur et le mot de passe comme non nuls.

• Vous pouvez également personnaliser d'autres fonctions dans le tableau. Cet exemple définit plusieurs fonctions couramment utilisées dans l'authentification des utilisateurs : is__activite(), get__id(), is__authenticate() et is_anonymous().

L'exemple de code pour définir une connexion à une base de données est le suivant :

from sqlalchemy import create_engine
from sqlalchemy.orm import scoped_session,sessionmaker
from contextlib import contextmanager

db_connect_string='mysql://v_user:v_pase@localhost:3306/test_database?charset=utf8'

ssl_args={
    'ssl':{
        'cert':'/home/ssl/client-cert.pem',
        'key':'/home/shouse/ssl/client-key.pem',
        'ca':'/home/shouse/ssl/ca-cert.pem'
    }
}
engine=create_engine(db_connect_string,connect_args=ssl_args)
SessionType=scoped_session(sessionmaker(bind=engine,expire_on_commit=False))
def GetSession():
    return SessionType()

@contextmanager
def session_scope():
    session=GetSession()
    try:
        yield session
        session.commit()
    except:
        session.rollback()
        raise
    finally:
        session.close()

Le code pour analyser la partie données de cette connexion est comme suit :

• Présentation des moteurs de base de données et de session : sqlalchemy.create_engine, sqlalchemy.orm.scoped_session, sqlalchemy.orm.sessionmaker.

• Définissez la chaîne de base de données nécessaire pour se connecter à la base de données. Dans cet exemple, la base de données MySQL est connectée. Le format de chaîne est [databse_type]://[user_name]:[password]@[domain]:[port]/[database]?[parameters. ]. Dans cet exemple, en plus des informations de connexion nécessaires, le paramètre charset est également transmis, spécifiant la méthode de codage UTF-8 pour décoder la chaîne dans la base de données.

• Utilisez create_engine pour créer un moteur de base de données Si la base de données a un lien SSL activé, vous devez transmettre ici le chemin du fichier du certificat client SSL.

• Utilisez scoped_session(sessionmaker(bind=engine)) pour créer le type de session SessionType et définissez la fonction GetSession() pour créer une instance de SessionType.

À ce stade, vous pouvez utiliser la fonction GetSession() pour créer une session de base de données et effectuer des opérations de base de données. Cependant, afin de permettre aux codes d'opération de base de données ultérieurs d'effectuer automatiquement le traitement des transactions, la fonction contextuelle session_scope() est définie dans cet exemple. La façon de définir une fonction contextuelle en Python consiste à ajouter le décorateur contextmanager dans le package contextlib. La logique suivante est exécutée dans la fonction contextuelle : une session de base de données est établie au début de la fonction, et une transaction de base de données est automatiquement établie à ce moment : la transaction est annulée lorsqu'une exception se produit ; la connexion est fermée à la sortie. L'opération de validation de transaction est automatiquement effectuée lorsque la connexion est fermée.

Code pour les opérations de base de données :

from sqlalchemy import or_,orm
def InsertAccount(user,passwd,title,salary): #新增操作
    with session_scope() as session:
        account=orm.Account(user_name=user,passwd=passwd,title=title,salary=salary)
        session.add(account)

def GetAccount(id=None,user_name=None): #查询操作
    with session_scope() as session:
        return session.query(orm.Account).filter(
            or_(orm.Account.id==id,orm.Account.user_name=user_name)
        ).first()

def DeleteAccount(user_name): #删除操作
    with session_scope() as session:
        account=GetAccount(user_name=user_name)
        if account:
            session.delete(account)

def UpdateAccount(id,user_name,password,title,salary):  #更新操作
    with session_scope() as session:
        account=session.query(orm.Account).filter(orm.Account.id==id).first()
        if not account:return
        account.user_name=user_name
        account.password=password
        account.salary=salary
        account.title=title


InsertAccount("Mark","123","Manager",3000)  #调用新增操作
InsertAccount("帅哥","456","Boss",2000)  #调用新增操作
GetAccount(2) #调用查询操作
DeleteAccount("Mark")
UpdateAccount(1,"admin","none","System admin",2500)

Cet exemple illustre les quatre opérations basées sur les enregistrements les plus couramment utilisées dans la base de données : ajouter, rechercher, supprimer, renouveler. L'analyse de cette partie du code est la suivante :

• Utilisez l'instruction import pour introduire le package orm où se trouve la table de données (Compte). Utilisez or_ lors de l'introduction de requêtes multiconditions.

• Dans chaque fonction, la fonction contextuelle session_scope() est activée via l'instruction with, à travers laquelle l'objet de session est obtenu et de nouvelles choses sont automatiquement démarrées.

• Dans InsertAccount, créez une nouvelle instance de table Account et ajoutez-la à la base de données via session.add. Étant donné que la transaction sera automatiquement validée à la fin de la fonction contextuelle, il n'est pas nécessaire d'appeler explicitement session.commit() pour que le nouvel ajout prenne effet.

• est interrogé via l'instruction de requête dans GetAccount. Les conditions de requête sont définies par filtre. Plusieurs conditions de requête peuvent être connectées à l'aide de or_ ou et_.

• Interrogez l'objet via GetAccount dans DeleteAccount. S'il est trouvé, appelez directement session.delete() pour supprimer l'objet.

• Dans InsertAccount(), interrogez l'enregistrement en fonction de l'identifiant via une requête. Si la requête est trouvée, modifiez l'enregistrement en définissant les propriétés de l'objet.

• Le résultat de l'instruction de requête est une collection d'objets. La fonction first() après l'instruction de requête est utilisée pour extraire le premier objet de la collection. Si la fonction first() est remplacée par la fonction all(), la requête renverra la collection.

Méthodes de connexion à la base de données grand public

Les méthodes de fonctionnement de la base de données Orm telles que SQLAlchemy peuvent protéger les développeurs commerciaux des différences entre les différentes bases de données, donc lors de la migration de la base de données est requis (comme MySQL vers SQLite), il vous suffit de modifier la chaîne de connexion à la base de données.

Le tableau suivant indique comment écrire des chaînes de base de données lorsque SQLAlchemy se connecte aux bases de données grand public :

数据库	连接字符串
Microsoft SQLServer	'mssql+pymssql://[user]:[pass]@[domain]:[port]/[dbname]'
MySQL	'mysql://[user]:[pass]@[domain]:[port]/[dbname]'
Oracle	'oracle://[user]:[pass]@[domain]:[port/[dbname]]'
PostgreSQL	'postgresql://[user]:[pass]@[domain]:[port]/[dbname]'
SQLite	'sqlite://[file_pathname]'

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!