SQLAlchemy is een SQL-tool gebouwd met Python die ontwikkelaars een overvloed aan krachtige functies biedt voor het ontwerpen en beheren van hoogwaardige databases.
We zullen kort ingaan op het gebruik van SQLAlchemy en vervolgens dieper ingaan op het uitvoeren van onbewerkte SQL-instructies vanuit het comfort van de Python-domeintaal.
SQLAlchemy gebruiken
Zoals bij alle Python-bibliotheken, begin je met het installeren van SQLAlchemy. Eenmaal geïnstalleerd kunnen we beginnen met het plezier in Python.
Importeer vervolgens sqlalchemy zelf, importeer dan een paar modules zodat we gemakkelijk toegang hebben tot de SQLAlchemy database-engine:
import sqlalchemy
from sqlalchemy import create_engine
from sqlalchemy import Table, Column, Integer, String, MetaData, ForeignKey
from sqlalchemy import inspect
Naast create_engine , importeren we ook een aantal extra modules die we nodig hebben om een nieuwe tabel te maken. Voordat we echter zover komen, moet u ervoor zorgen dat SQLAlchemy is geïnstalleerd, geïmporteerd en werkt door .__version__ aan te roepen zoals zo:
print sqlalchemy.__version__
Out[*]: 1.0.9
Een tabel maken
We zullen de basisfunctionaliteit van SQLAlchemy, de SQL Expression Language, gebruiken om enkele metadata te maken dat een aantal gerelateerde modules (of objecten) zal bevatten die ons nieuwe book definiëren databasetabel:
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)
Bovenaan definiëren we metadata , dan geven we dat door aan de Table() methode, waarbij we onze tabel de naam geven book . Hierin definiëren we elke kolom, samen met belangrijke attributen zoals gegevenstype en primary_key .
Zodra onze tabel(len) zijn gedefinieerd en gekoppeld aan onze metadata object, moeten we een database-engine maken waarmee we verbinding kunnen maken. Dit wordt bereikt met behulp van de create_engine functie.
engine = create_engine('sqlite:///bookstore.db')
Voor ons voorbeeld gebruiken we een eenvoudige SQLite databank. U kunt ook verbindingsreeksen gebruiken voor andere engines, zoals MySQL of PostgreSQL. Hier is een voorbeeldsyntaxis voor het maken van een engine voor PostgreSQL:
engine = create_engine('postgresql://user:password@host/database')
Nu de engine is gemaakt, moeten we nu de .create_all() . gebruiken methode van onze metadata object en geef de engine door verbinding ermee, waardoor SQLAlchemy automatisch onze tabel voor ons genereert, zoals hierboven te zien is.
Als dat klaar is, kunnen we de tafel naar eigen inzicht gebruiken. In dit eenvoudige voorbeeld gebruiken we gewoon de inspect module om de kolommen te bekijken en te controleren of onze tabel met succes is gemaakt:
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()}]
En ja hoor, met behulp van de .get_columns() methode voor ons book tabel, zien we dat onze drie kolommen zijn gegenereerd.
SQL-statements uitvoeren
Nu de basis op orde is, kunnen we nu proberen wat onbewerkte SQL uit te voeren met SQLAlchemy.
De tekstmodule gebruiken
Een methode voor het uitvoeren van onbewerkte SQL is het gebruik van de text module, of Textual SQL . De meest leesbare manier om text te gebruiken is om de module te importeren, dan na verbinding te hebben gemaakt met de engine , definieer de text SQL-instructiereeks voordat u .execute gebruikt om het uit te voeren:
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)
Hier voegen we twee records in onze database in met behulp van een text() -gedefinieerde verklaring.
De execute methode gebruiken
De alternatieve methode is om text() . over te slaan en geef een onbewerkte SQL-string door aan de .execute() methode. Hier gebruiken we bijvoorbeeld .execute() om de nieuwe records te bekijken die we hierboven hebben ingevoegd:
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')
Daar hebben we het! Eenvoudige en effectieve methoden voor het uitvoeren van onbewerkte SQL-instructies in SQLAlchemy.