SQLAlchemy ist ein mit Python erstelltes SQL-Tool, das Entwicklern eine Fülle leistungsstarker Funktionen zum Entwerfen und Verwalten von Hochleistungsdatenbanken bietet.
Wir werden kurz untersuchen, wie SQLAlchemy verwendet wird, und dann tiefer in die Ausführung von rohen SQL-Anweisungen aus dem Komfort der Python-Domänensprache eintauchen.
SQLAlchemy verwenden
Beginnen Sie wie bei allen Python-Bibliotheken mit der Installation von SQLAlchemy. Nach der Installation können wir mit dem Spaß in Python beginnen.
Als nächstes importieren Sie sqlalchemy selbst, dann importieren Sie einige Module, damit wir einfach auf die SQLAlchemy-Datenbank-Engine zugreifen können:
import sqlalchemy
from sqlalchemy import create_engine
from sqlalchemy import Table, Column, Integer, String, MetaData, ForeignKey
from sqlalchemy import inspect
Zusätzlich zu create_engine , importieren wir auch eine Reihe zusätzlicher Module, die wir zum Erstellen einer neuen Tabelle benötigen. Bevor wir dazu kommen, stellen Sie jedoch sicher, dass SQLAlchemy installiert und importiert wurde und funktioniert, indem Sie .__version__ aufrufen so:
print sqlalchemy.__version__
Out[*]: 1.0.9
Eine Tabelle erstellen
Wir verwenden die grundlegende Funktionalität von SQLAlchemy, der SQL Expression Language, um einige metadata zu erstellen das eine Reihe verwandter Module (oder Objekte) enthalten wird, die unser neues book definieren Datenbanktabelle:
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)
Ganz oben definieren wir metadata , dann übergeben wir das an die Table() Methode, wo wir unserer Tabelle den Namen book geben . Darin definieren wir jede Spalte zusammen mit wichtigen Attributen wie Datentyp und primary_key .
Sobald unsere Tabelle(n) definiert und mit unseren metadata verknüpft sind -Objekt müssen wir eine Datenbank-Engine erstellen, mit der wir uns verbinden können. Dies wird mit der create_engine erreicht Funktion.
engine = create_engine('sqlite:///bookstore.db')
Für unser Beispiel verwenden wir ein einfaches SQLite Datenbank. Sie können Verbindungszeichenfolgen auch für andere Engines wie MySQL oder PostgreSQL verwenden. Hier ist eine Beispielsyntax zum Erstellen einer Engine für PostgreSQL:
engine = create_engine('postgresql://user:password@host/database')
Nachdem die Engine erstellt wurde, müssen wir nun .create_all() verwenden Methode unserer metadata -Objekt und übergeben Sie die engine Verbindung dazu, wodurch SQLAlchemy automatisch unsere Tabelle für uns generiert, wie oben gezeigt.
Wenn dies abgeschlossen ist, können wir die Tabelle so verwenden, wie wir es für richtig halten. In diesem einfachen Beispiel verwenden wir einfach den inspect Modul, um die Spalten anzuzeigen und zu überprüfen, ob unsere Tabelle erfolgreich erstellt wurde:
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()}]
Sicher genug, mit .get_columns() Methode für unser book Tabelle sehen wir, dass unsere drei Spalten generiert wurden.
Ausführen von SQL-Anweisungen
Nachdem die Grundlagen vorhanden sind, können wir nun versuchen, etwas rohes SQL mit SQLAlchemy auszuführen.
Verwendung des Textmoduls
Eine Methode zum Ausführen von Raw-SQL ist die Verwendung von text Modul oder Textual SQL . Die am besten lesbare Art, text zu verwenden ist das Modul zu importieren, dann nach dem Verbinden mit der engine , definieren Sie den text SQL-Anweisungszeichenfolge vor der Verwendung von .execute um es auszuführen:
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 fügen wir zwei Datensätze in unsere Datenbank ein, indem wir einen text() verwenden -definierte Anweisung.
Verwendung der execute-Methode
Die alternative Methode ist das Überspringen mit text() und übergeben Sie einen rohen SQL-String an .execute() Methode. Hier verwenden wir beispielsweise .execute() um die neuen Datensätze anzuzeigen, die wir oben eingefügt haben:
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')
Da haben wir es! Einfache und effektive Methoden zum Ausführen von rohen SQL-Anweisungen in SQLAlchemy.
