SQLAlchemy è uno strumento SQL creato con Python che fornisce agli sviluppatori un'abbondanza di potenti funzionalità per la progettazione e la gestione di database ad alte prestazioni.
Esploreremo brevemente come utilizzare SQLAlchemy e poi approfondiremo come eseguire istruzioni SQL grezze dalla comodità del linguaggio di dominio Python.
Utilizzo di SQLAlchemy
Come con tutte le librerie Python, inizia installando SQLAlchemy. Una volta installato, possiamo iniziare il divertimento in Python.
Quindi, importa sqlalchemy stesso, quindi importare alcuni moduli in modo da poter accedere facilmente al motore di database SQLAlchemy:
import sqlalchemy
from sqlalchemy import create_engine
from sqlalchemy import Table, Column, Integer, String, MetaData, ForeignKey
from sqlalchemy import inspect
Oltre a create_engine , stiamo anche importando una serie di moduli aggiuntivi di cui avremo bisogno per creare una nuova tabella. Prima di arrivare a questo, assicurati che SQLAlchemy sia stato installato, importato e funzioni chiamando .__version__ così:
print sqlalchemy.__version__
Out[*]: 1.0.9
Creazione di una tabella
Utilizzeremo le funzionalità di base di SQLAlchemy che è il linguaggio di espressione SQL per creare alcuni metadata che conterrà un numero di moduli (o oggetti) correlati che definiscono il nostro nuovo book tabella del database:
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)
In alto definiamo metadata , quindi lo passiamo nella Table() metodo, dove diamo alla nostra tabella il nome book . All'interno di questo, definiamo ogni colonna, insieme ad attributi importanti come il tipo di dati e primary_key .
Una volta che le nostre tabelle sono state definite e associate ai nostri metadata oggetto, dobbiamo creare un motore di database con cui possiamo connetterci. Questo si ottiene usando il create_engine funzione.
engine = create_engine('sqlite:///bookstore.db')
Per il nostro esempio, useremo un semplice SQLite Banca dati. Puoi anche utilizzare stringhe di connessione per altri motori come MySQL o PostgreSQL. Ecco un esempio di sintassi per la creazione di un motore per PostgreSQL:
engine = create_engine('postgresql://user:password@host/database')
Con il motore creato, ora dobbiamo usare .create_all() metodo dei nostri metadata oggetto e passare il engine connessione ad esso, che farà automaticamente in modo che SQLAlchemy generi la nostra tabella per noi, come visto sopra.
Una volta completato, possiamo usare la tabella come riteniamo opportuno. In questo semplice esempio, useremo semplicemente inspect modulo per visualizzare le colonne e verificare che la nostra tabella sia stata creata correttamente:
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()}]
Abbastanza sicuro, usando il .get_columns() metodo per il nostro book tabella, vediamo che le nostre tre colonne sono state generate.
Esecuzione di istruzioni SQL
Con le basi in atto, ora possiamo provare a eseguire un SQL grezzo utilizzando SQLAlchemy.
Utilizzo del modulo di testo
Un metodo per eseguire l'SQL grezzo consiste nell'usare il text modulo o Textual SQL . Il modo più leggibile per usare text è importare il modulo, quindi dopo esserti connesso al engine , definisci il text Stringa di istruzione SQL prima di utilizzare .execute per eseguirlo:
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)
Qui stiamo inserendo due record nel nostro database usando un text() dichiarazione definita.
Utilizzo del metodo di esecuzione
Il metodo alternativo è saltare usando text() e passa una stringa SQL grezza a .execute() metodo. Ad esempio, qui useremo .execute() per visualizzare i nuovi record che abbiamo inserito sopra:
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')
Eccolo qua! Metodi semplici ed efficaci per eseguire istruzioni SQL grezze in SQLAlchemy.
