Jak wykonać surowy SQL w SQLAlchemy

SQLAlchemy to narzędzie SQL zbudowane w Pythonie, które zapewnia programistom mnóstwo zaawansowanych funkcji do projektowania i zarządzania wysokowydajnymi bazami danych.

Pokrótce omówimy, jak używać SQLAlchemy, a następnie zagłębimy się w sposób wykonywania surowych instrukcji SQL w wygodnym języku domeny Python.

Korzystanie z SQLAlchemy

Podobnie jak w przypadku wszystkich bibliotek Pythona, zacznij od zainstalowania SQLAlchemy. Po zainstalowaniu możemy rozpocząć zabawę w Pythonie.

Następnie zaimportuj sqlalchemy sam, a następnie zaimportuj kilka modułów, abyśmy mogli łatwo uzyskać dostęp do silnika bazy danych SQLAlchemy:

import sqlalchemy
from sqlalchemy import create_engine
from sqlalchemy import Table, Column, Integer, String, MetaData, ForeignKey
from sqlalchemy import inspect

Oprócz create_engine , importujemy również szereg dodatkowych modułów, które będą nam potrzebne do utworzenia nowej tabeli. Zanim jednak do tego dojdziemy, upewnij się, że SQLAlchemy został zainstalowany, zaimportowany i działa, wywołując .__version__ tak:

print sqlalchemy.__version__
Out[*]: 1.0.9

Tworzenie tabeli

Będziemy używać podstawowej funkcjonalności SQLAlchemy, która jest językiem SQL Expression Language, do tworzenia niektórych metadata który będzie zawierał szereg powiązanych modułów (lub obiektów), które definiują naszą nową book tabela bazy danych:

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)

Na górze definiujemy metadata , następnie przekazujemy to do Table() metody, w której nadajemy naszej tabeli nazwę book . W ramach tego definiujemy każdą kolumnę wraz z ważnymi atrybutami, takimi jak typ danych i primary_key .

Gdy nasze tabele zostaną zdefiniowane i powiązane z naszymi metadata obiekt, musimy stworzyć silnik bazy danych, z którym możemy się połączyć. Odbywa się to za pomocą create_engine funkcja.

engine = create_engine('sqlite:///bookstore.db')

W naszym przykładzie użyjemy prostego SQLite Baza danych. Możesz także użyć parametrów połączenia dla innych silników, takich jak MySQL lub PostgreSQL. Oto przykładowa składnia tworzenia silnika dla PostgreSQL:

engine = create_engine('postgresql://user:password@host/database')

Po utworzeniu silnika musimy teraz użyć .create_all() metoda naszych metadata obiekt i przekazać engine połączenie z nim, co automatycznie spowoduje, że SQLAlchemy wygeneruje dla nas naszą tabelę, jak widać powyżej.

Mając to kompletne, możemy użyć tabeli według własnego uznania. W tym prostym przykładzie użyjemy po prostu inspect moduł do przeglądania kolumn i sprawdzenia, czy nasza tabela została pomyślnie utworzona:

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()}]

Rzeczywiście, używając .get_columns() metoda dla naszej book tabeli, widzimy, że wygenerowano nasze trzy kolumny.

Wykonywanie instrukcji SQL

Mając podstawy, możemy teraz spróbować wykonać surowy SQL przy użyciu SQLAlchemy.

Korzystanie z modułu tekstowego

Jedną z metod wykonywania surowego SQL jest użycie text lub Textual SQL . Najbardziej czytelny sposób użycia text jest zaimportowanie modułu, to po podłączeniu do engine , zdefiniuj text Ciąg instrukcji SQL przed użyciem .execute aby go uruchomić:

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)

Tutaj wstawiamy dwa rekordy do naszej bazy danych za pomocą text() -zdefiniowane oświadczenie.

Korzystanie z metody wykonywania

Alternatywną metodą jest pominięcie przy użyciu text() i przekaż nieprzetworzony ciąg SQL do .execute() metoda. Na przykład tutaj użyjemy .execute() aby zobaczyć nowe rekordy, które wstawiliśmy powyżej:

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')

Mamy to! Proste i efektywne metody wykonywania surowych instrukcji SQL w SQLAlchemy.