SQLAlchemy est un outil SQL construit avec Python qui offre aux développeurs une multitude de fonctionnalités puissantes pour concevoir et gérer des bases de données hautes performances.
Nous allons brièvement explorer comment utiliser SQLAlchemy, puis approfondir la façon d'exécuter des instructions SQL brutes dans le confort du langage de domaine Python.
Utiliser SQLAlchemy
Comme pour toutes les bibliothèques Python, commencez par installer SQLAlchemy. Une fois installé, nous pouvons commencer à nous amuser en Python.
Ensuite, importez sqlalchemy lui-même, puis importez quelques modules afin que nous puissions facilement accéder au moteur de base de données SQLAlchemy :
import sqlalchemy
from sqlalchemy import create_engine
from sqlalchemy import Table, Column, Integer, String, MetaData, ForeignKey
from sqlalchemy import inspect
En plus de create_engine , nous importons également un certain nombre de modules supplémentaires dont nous aurons besoin pour créer une nouvelle table. Avant d'en arriver là, assurez-vous que SQLAlchemy a été installé, importé et fonctionne en appelant .__version__ comme ça :
print sqlalchemy.__version__
Out[*]: 1.0.9
Créer un tableau
Nous utiliserons la fonctionnalité de base de SQLAlchemy qui est le langage d'expression SQL pour créer des metadata qui contiendra un certain nombre de modules (ou objets) associés qui définissent notre nouveau book table de base de données :
metadata = MetaData()
books = Table('book', metadata,
Column('id', Integer, primary_key=True),
Column('title', String),
Column('primary_author', String),
)
engine = create_engine('sqlite:///bookstore.db')
metadata.create_all(engine)
En haut, nous définissons metadata , puis nous le passons dans le Table() méthode, où nous donnons à notre table le nom book . Dans ce cadre, nous définissons chaque colonne, ainsi que des attributs importants tels que le type de données et primary_key .
Une fois nos tables définies et associées à nos metadata objet, nous devons créer un moteur de base de données avec lequel nous pouvons nous connecter. Ceci est accompli en utilisant le create_engine fonction.
engine = create_engine('sqlite:///bookstore.db')
Pour notre exemple, nous utiliserons un simple SQLite base de données. Vous pouvez également utiliser des chaînes de connexion pour d'autres moteurs tels que MySQL ou PostgreSQL. Voici un exemple de syntaxe pour créer un moteur pour PostgreSQL :
engine = create_engine('postgresql://user:password@host/database')
Avec le moteur créé, nous devons maintenant utiliser le .create_all() méthode de nos metadata objet et passer le engine connexion à celui-ci, ce qui entraînera automatiquement SQLAlchemy à générer notre table pour nous, comme indiqué ci-dessus.
Une fois cela terminé, nous pouvons utiliser le tableau comme bon nous semble. Dans cet exemple simple, nous allons simplement utiliser le inspect module pour afficher les colonnes et vérifier que notre table a été créée avec succès :
inspector = inspect(engine)
inspector.get_columns('book')
Out[*]:
[{'autoincrement': True,
'default': None,
'name': u'id',
'nullable': False,
'primary_key': 1,
'type': INTEGER()},
{'autoincrement': True,
'default': None,
'name': u'title',
'nullable': True,
'primary_key': 0,
'type': VARCHAR()},
{'autoincrement': True,
'default': None,
'name': u'primary_author',
'nullable': True,
'primary_key': 0,
'type': VARCHAR()}]
Effectivement, en utilisant le .get_columns() méthode pour notre book table, nous voyons que nos trois colonnes ont été générées.
Exécuter des instructions SQL
Avec les bases en place, nous pouvons maintenant essayer d'exécuter du SQL brut à l'aide de SQLAlchemy.
Utilisation du module de texte
Une méthode pour exécuter du SQL brut consiste à utiliser le text module, ou Textual SQL . La façon la plus lisible d'utiliser text est d'importer le module, puis après s'être connecté au engine , définissez le text Chaîne d'instruction SQL avant d'utiliser .execute pour l'exécuter :
from sqlalchemy.sql import text
with engine.connect() as con:
data = ( { "id": 1, "title": "The Hobbit", "primary_author": "Tolkien" },
{ "id": 2, "title": "The Silmarillion", "primary_author": "Tolkien" },
)
statement = text("""INSERT INTO book(id, title, primary_author) VALUES(:id, :title, :primary_author)""")
for line in data:
con.execute(statement, **line)
Ici, nous insérons deux enregistrements dans notre base de données en utilisant un text() -instruction définie.
Utilisation de la méthode d'exécution
La méthode alternative consiste à ignorer l'utilisation de text() et passez une chaîne SQL brute au .execute() méthode. Par exemple, ici nous utiliserons .execute() pour afficher les nouveaux enregistrements que nous avons insérés ci-dessus :
with engine.connect() as con:
rs = con.execute('SELECT * FROM book')
for row in rs:
print row
Out[*]:
(4, u'The Hobbit', u'Tolkien')
(5, u'The Silmarillion', u'Tolkien')
Nous l'avons! Méthodes simples et efficaces pour exécuter des instructions SQL brutes dans SQLAlchemy.
