Hur man kör Raw SQL i SQLAlchemy

SQLAlchemy är ett SQL-verktyg byggt med Python som ger utvecklare ett överflöd av kraftfulla funktioner för att designa och hantera högpresterande databaser.

Vi ska kort utforska hur man använder SQLAlchemy och sedan dyka djupare in i hur man exekverar obearbetade SQL-satser från bekvämligheten av Python-domänspråket.

Använda SQLAlchemy

Som med alla Python-bibliotek, börja med att installera SQLAlchemy. När det väl är installerat kan vi börja det roliga i Python.

Importera sedan sqlalchemy själv, importera sedan några moduler så att vi enkelt kan komma åt SQLAlchemys databasmotor:

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

Förutom create_engine , importerar vi också ett antal ytterligare moduler som vi behöver för att skapa en ny tabell. Innan vi kommer till det, se till att SQLAlchemy har installerats, importerats och fungerar genom att anropa .__version__ som så:

print sqlalchemy.__version__
Out[*]: 1.0.9

Skapa en tabell

Vi kommer att använda den grundläggande funktionaliteten i SQLAlchemy som är SQL Expression Language för att skapa lite metadata som kommer att innehålla ett antal relaterade moduler (eller objekt) som definierar vår nya book databastabell:

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)

Överst definierar vi metadata , sedan skickar vi det till Table() metod, där vi ger vår tabell namnet book . Inom detta definierar vi varje kolumn, tillsammans med viktiga attribut som datatyp och primary_key .

När våra tabeller är definierade och associerade med vår metadata objekt måste vi skapa en databasmotor som vi kan ansluta till. Detta görs med hjälp av create_engine funktion.

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

För vårt exempel kommer vi att använda en enkel SQLite databas. Du kan också använda anslutningssträngar för andra motorer som MySQL eller PostgreSQL. Här är ett exempel på syntax för att skapa en motor för PostgreSQL:

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

Med motorn skapad måste vi nu använda .create_all() metod för vår metadata objekt och skicka engine anslutning till den, vilket automatiskt gör att SQLAlchemy genererar vår tabell åt oss, som ses ovan.

Med det färdigt kan vi använda bordet som vi tycker är lämpligt. I detta enkla exempel använder vi bara inspect modul för att se kolumnerna och verifiera att vår tabell skapades:

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

Visst nog, med .get_columns() metod för vår book tabell, ser vi att våra tre kolumner genererades.

Köra SQL-satser

Med grunderna på plats kan vi nu prova att köra lite rå SQL med SQLAlchemy.

Använda textmodulen

En metod för att köra rå SQL är att använda text modul, eller Textual SQL . Det mest läsbara sättet att använda text är att importera modulen, sedan efter anslutning till engine , definiera text SQL-satssträng innan du använder .execute för att köra det:

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)

Här infogar vi två poster i vår databas genom att använda en text() -definierat uttalande.

Använda exekveringsmetoden

Den alternativa metoden är att hoppa över text() och skicka en rå SQL-sträng till .execute() metod. Här kommer vi till exempel att använda .execute() för att se de nya posterna vi infogade ovan:

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

Där har vi det! Enkla och effektiva metoder för att exekvera obearbetade SQL-satser i SQLAlchemy.