Tout ce que vous devez savoir sur les cartes Python et relationnelles objet

Added 2018-07-11

Vous avez peut-être entendu parler du mappage relationnel-objet (ORM). Vous en avez peut-être même utilisé un, mais quels sont-ils exactement? Et comment les utilisez-vous en Python?

Voici tout ce que vous devez savoir sur les ORM et Python.

Qu'est-ce qu'un ORM?

Le mappage objet-relationnel (ORM) est une technique de programmation utilisée pour accéder à une base de données. Il expose votre base de données dans une série d'objets. Il n’est pas nécessaire d’écrire des commandes SQL pour insérer ou récupérer des données, vous utilisez une série d’attributs et de méthodes attachés à des objets.

Cela peut sembler complexe et inutile, mais ils peuvent vous faire gagner beaucoup de temps et vous aider à contrôler l'accès à votre base de données.

En utilisant un ORM, vous pouvez écrire du code pour vous assurer que chaque fois que vous accédez à une ligne ou à un champ de votre base de données, votre autre code personnalisé est exécuté en premier.

Il y a certaines choses à surveiller lors de l'utilisation d'un ORM, et il y a des circonstances dans lesquelles vous ne souhaitez peut-être pas en utiliser un, mais elles sont généralement considérées comme une bonne chose à avoir, en particulier dans une base de code volumineuse.

ORM en Python utilisant SQLAlchemy

Comme beaucoup de tâches en Python, il est plus rapide et plus facile d’importer un module que d’écrire le vôtre. Bien sûr, il est possible d’écrire votre propre ORM, mais pourquoi réinventer la roue?

Les exemples suivants utilisent tous SQLAlchemy , un ORM Python populaire, mais bon nombre des principes s’appliquent quelle que soit la mise en œuvre.

Configuration de Python pour SQLAlchemy

Avant de vous lancer, vous devez configurer votre machine pour le développement Python avec SQLAlchemy.

Une fois que vous êtes prêt, vous pouvez commencer par préparer SQLAlchemy. À partir de votre environnement Python en ligne de commande, installez SQLAlchemy avec le pip installer commander:


pip installer SQLAlchemy-1.2.9

le 1.2.9 est le numéro de version. Vous pouvez laisser cette option pour obtenir le dernier package, mais il est judicieux d’être précis. Vous ne savez pas quand une nouvelle version peut casser votre code actuel.

Installer SQLAlchemy sur votre PC

Vous êtes maintenant prêt à commencer à coder. Vous devrez peut-être préparer votre base de données pour accepter une connexion Python, mais les exemples suivants utilisent tous un exemple. SQLite base de données créée en mémoire ci-dessous.

Modèles dans SQLAlchemy

L’un des composants clés d’un ORM est un modèle . Il s'agit d'une classe Python qui décrit à quoi une table devrait ressembler et comment elle devrait fonctionner. C’est la version ORM du CREER LA TABLE déclaration en SQL. Vous avez besoin d'un modèle pour chaque table de votre base de données.

Ouvrez votre éditeur de texte préféré ou votre IDE et créez un nouveau fichier appelé test.py . Entrez ce code de démarrage, enregistrez le fichier et exécutez-le:


depuis sqlalchemy import create_engine
from sqlalchemy.ext.declarative import déclarative_base

Base = déclarative_base ()

engine = create_engine ('sqlite: //') # Crée la base de données en mémoire
Base.metadata.create_all (engine) # Crée toutes les tables de la base de données

Ce code fait plusieurs choses. Les importations sont nécessaires pour que Python sache où trouver les modules SQLAlchemy dont il a besoin. Vos modèles utiliseront le base de déclaration plus tard, et il configure tous les nouveaux modèles pour fonctionner comme prévu.

le create_engine Cette méthode crée une nouvelle connexion à votre base de données. Si vous avez déjà une base de données, vous devrez changer sqlite: // à votre URI de base de données. En l'état, ce code créera une nouvelle base de données uniquement en mémoire. La base de données est détruite une fois l'exécution de votre code terminée.

Finalement, le create_all method crée toutes les tables définies dans vos modes dans votre base de données. Comme vous n'avez encore défini aucun modèle, rien ne se passera. Continuez et exécutez ce code pour vous assurer que vous n’aurez aucun problème ni aucune faute de frappe.

Faisons un modèle. Ajoutez une autre importation en haut de votre fichier:


depuis sqlalchemy import Column, Integer, String

Cela importe le Colonne , Entier , et Chaîne modules de SQLAlchemy. Ils définissent le fonctionnement des tables, des champs, des colonnes et des types de données de la base de données.

Sous le base de déclaration , créez votre classe de modèle:


Classe Voitures (Base):
  __tablename__ = 'cars'
  id = Column (Integer, primary_key = True)
  make = Column (String (50), nullable = False)
  color = Column (String (50), nullable = False)

Cet exemple simple utilise des voitures, mais vos tables peuvent contenir des données.

Chaque classe doit hériter Base . Le nom de votre table de base de données est défini dans __nom de la table__ . Cela devrait être identique au nom de la classe, mais il ne s’agit que d’une recommandation, et rien ne se brisera s’ils ne correspondent pas.

Enfin, chaque colonne est définie en tant que variable python dans la classe. Différents types de données sont utilisés, et le clé primaire attribut dit à SQLAlchemy de créer le identifiant colonne en tant que clé primaire.

Allez-y et ajoutez une dernière importation, cette fois pour le Clé étrangère module. Ajoutez ceci aux côtés de votre Colonne importation:


à partir de sqlalchemy import Column, ForeignKey, Integer, String

Créez maintenant une deuxième classe de modèle. Cette classe s'appelle Propriétaires , et stocke les détails du propriétaire de certaines voitures stockées dans Des voitures table:


classe CarOwners (Base):
  __tablename__ = 'propriétaires'
  id = Column (Integer, primary_key = True)
  name = Column (String (50), nullable = False)
  age = Column (Integer, nullable = False)
  car_id = Column (Integer, ForeignKey ('cars.id'))

  voiture = relation (Voitures)

Il y a plusieurs nouveaux attributs introduits ici. le car_id champ est défini comme une clé étrangère. Il est lié à la identifiant dans le des voitures table. Notez comment le nom de la table en minuscule est utilisé, instable du nom de la classe en majuscule.

Enfin, un attribut de voiture est défini comme un relation . Cela permet à votre modèle d'accéder à la Des voitures table à travers cette variable. Ceci est démontré ci-dessous.

Si vous exécutez ce code maintenant, vous verrez que rien ne se produit. C’est parce que vous ne lui avez pas encore demandé de faire quoi que ce soit de notable.

Objets dans SQLAlchemy

Maintenant que vos modèles sont créés, vous pouvez commencer à accéder aux objets et à lire et écrire des données. C’est une bonne idée de placer votre logique dans sa propre classe et fichier, mais pour l’instant, elle peut rester aux côtés des modèles.

Écriture de données

Dans cet exemple, vous devez insérer des données dans la base de données avant de pouvoir les lire. Si vous utilisez une base de données existante, vous avez peut-être déjà des données. Quoi qu’il en soit, il est toujours très utile de savoir comment insérer des données.

Vous pouvez être habitué à écrire INSÉRER instructions en SQL. SQLAlchemy s'en occupe pour vous. Voici comment insérer une rangée dans le Des voitures modèle. Commencez avec une nouvelle importation pour faiseur de session :


à partir de sqlalchemy.orm sessionmaker

Cela est nécessaire pour créer le session et DBSession objets, qui sont utilisés pour lire et écrire des données:


DBSession = sessionmaker (bind = engine)
session = DBSession ()

Maintenant, placez ceci sous votre create_all déclaration:


car1 = Voitures (
  make = "Ford",
  couleur = "argent"
)
session.add (car1)
session.commit ()

Décomposons ce code. La variable voiture1 est défini comme un objet basé sur la Des voitures modèle. Sa marque et sa couleur sont définies en tant que paramètres. C’est comme dire «fais-moi une voiture, mais ne l’écris pas encore dans la base de données». Cette voiture existe en mémoire mais attend d’être écrite.

Ajouter la voiture à la session avec session.add , puis écrivez-le dans la base de données avec session.commit .

Ajoutons maintenant un propriétaire:


owner1 = CarOwners (
  name = "Joe",
  age = "99",
  car_id = (car1.id)
)
session.add (propriétaire1)
session.commit ()

Ce code est presque identique à l’insertion précédente du Des voitures modèle. La principale différence ici est que car_id est une clé étrangère, il faut donc un identifiant de ligne qui existe dans l'autre table. Ceci est accessible via le car1.id propriété.

Vous n’avez pas à interroger la base de données ni à renvoyer d’id, car SQLAlchemy s’occupe de cela à votre place (à condition de valider d’abord les données).

Lecture de données

Une fois que vous avez écrit certaines données, vous pouvez commencer à les relire. Voici comment interroger le Des voitures et Propriétaires les tables:


result = session.query (Cars) .all ()

C'est aussi simple que ça. En utilisant le question méthode trouvée dans le session , vous spécifiez le modèle, puis utilisez le tout méthode pour récupérer tous les résultats. Si vous savez qu'il n'y aura qu'un seul résultat, vous pouvez utiliser le premier méthode:


result = session.query (Cars) .first ()

Une fois que vous avez interrogé le modèle et stocké vos résultats renvoyés dans une variable, vous pouvez accéder aux données via l'objet:


print (result [0] .color)

Ceci affiche la couleur «argent», car cet enregistrement est la première ligne. Vous pouvez faire une boucle sur l'objet résultat si vous le souhaitez.

Exemple de requête Python ORM

Lorsque vous avez défini la relation dans votre modèle, il est possible d’accéder aux données des tables associées sans spécifier de jointure:


result = session.query (CarOwners) .all ()
print (résultat [0] .name)
print (résultat [0] .car.color)

Résultat de requête de base de données simple en utilisant ORM

Cela fonctionne car votre modèle contient des détails sur la structure de votre table et voiture attribut a été défini comme un lien vers la des voitures table.

Qu'est-ce qui ne doit pas plaire aux ORM?

Ce tutoriel ne couvrait que les bases, mais une fois que vous en avez maîtrisé les bases, vous pouvez passer aux sujets avancés. Les ORM présentent certains inconvénients potentiels:

Vous devez écrire votre modèle avant qu'aucune requête ne puisse être exécutée.
C’est une autre nouvelle syntaxe à apprendre.
C'est peut-être trop complexe pour des besoins simples.
Vous devez avoir une bonne conception de base de données pour commencer.

Ces problèmes ne sont pas un gros problème en eux-mêmes, mais ce sont des choses à surveiller. Si vous travaillez avec une base de données existante, vous risquez d’être pris au dépourvu.