Wstęp

SQLAlchemy jest zestawem pythonowych narzędzi SQL i ORM znacznie pomagającym programiście przy pracy z bazami danych.
Obsługuje następujące bazy danych: MySQL, SQLite, PostgreSQL, Oracle, MS-SQL i Firebird.


Instalacja

Jest kilka sposób instalacji, ze względu na prostotę polecam:

easy_install sqlalchemy

Jeżeli nie korzystasz z konta roota, prawdopodobnie będziesz musiał skorzystać z sudo.
Zastrzegam, że to nie jedyny sposób instalacji (;


ORM

ORM – ang. Object-Relational Mapping co w dosłownym tłumaczeniu znaczy Mapowanie Obiektowo-Relacyjne. Polega to mniej więcej na odwzorowaniu struktury obiektowej na relacyjnej bazie danych.


Pierwszy raz

Mniej więcej wyjaśniliśmy sobie kilka pojęć związanych z SQLAlchemy. Poznaliśmy prostą metodę instalacji i definicję ORM. Posiadając taką wiedzę czas na pokazanie i wytłumaczenie prostego przykładu „w kodzie”. Stwórz plik „przyklad.py„, zamieść w nim zawartość poniższego listingu i zapisz.

# -*- coding: utf-8 -*-
from sqlalchemy import *

db = create_engine('sqlite:///przyklad.db')

db.echo = False # Spróbuj zmienić na true (:. To taki odpowednik "verbose"

metadata = MetaData(db)

users = Table('users', metadata,
    Column('user_id', Integer, primary_key=True),
    Column('name', String(255)),
    Column('job', Integer),
    Column('pass', String(255)),
)
users.create() # Tworzymy tabelę

insert = users.insert()

insert.execute(name='Michal', job: 'Bezrobotny', pass='sekretne')

insert.execute({'name': 'Jan', 'job': 'Handlowiec', 'pass': 'tajne'},
          {'name': 'Kuba', 'job': 'Wozny'},
          {'name': 'Ola', 'job': 'Handlowiec'}) # Wkładamy dane

select = users.select()
result = select.execute()

wszystko = result.fetchall()
row = result.fetchone()
print 'Id:', row['user_id']
print 'Imie:', row['name']
print 'Praca:', row.job
print 'Haslo:', row['pass']

for row in wszystko: 
    print row.name, 'pracuje jako', row.job

Aby uruchomić nasz mały program wpisz w konsolę:

pyhton przyklad.py

Abyśmy mogli operwać na tabelach musieliśmy przypisać je do obiektu MetaData(). Teraz dopiero możemy stworzyć tabelę users. W przykładzie pokazałem dwa sposoby dodawania danych do bazy. Pierwszy pozwala na dodanie pojedyńczego obiektu, natomiast za pomocą drugiego sposobu podajemy listę słowników, żeby dodać wiele obiektów na raz. Jeżeli SQLAlchemy w naszych danych znajdzie się jakiś znak specjalny(np. apostrofę lub średnik) to SQLEngine automatycznie je zasleszuje. Dzięki takiej ochronie, atak SQL Injection staje się praktycznie niemożliwy. W SQLAlchemy pobieranie danych nie stanowi żadnego problemu, żeby pobrać jeden wiersz skorzystałem z funkcji fetchone(), natomiast żeby pobrać wszystkie rekordy na raz skorzystałem z fetchall() i wylistowałem je za pomocą pętli for, której obsługa w pythonie jest wyjątkowo prosta. Pewnie zwróciłeś uwagę to to, że korzystamy z sqlite. Jak już pewnie wiesz to nie jedyna baza obsługiwana przez SQLAlchemy. Poniżej przedstawiam sposoby łączenia się z innymi bazami danych:


db = create_engine('postgres://login:haslo@localhost:port/nazwabazydanych') # PostgreSQL
db = create_engine('mysql://login:haslo@localhost:port/nazwabazydanych') #MySQL
db = create_engine('oracle://login:haslo@localhost:port/nazwabazydanych') #Oracle

# Łączenie z bazami danych odbywa się za pomocą pewnego schematu:
# driver://login:haslo@host:port/nazwabazydanych

db = create_engine('sqlite:////bezwzgledna/sciezka/do/bazydanych.db') 
db = create_engine('sqlite:///relatywna/sciezka/do/bazydanych.db')
db = create_engine('sqlite://')  # baza w pamięci RAM



Pobieranie danych – szczegółowo

Poświęćmy trochę czasu, aby zbadać różne sposoby pobierania danych z bazy przy pomocy SQLAlchemy, które skracają czas pracy i pomagają programiście tworzyć zaawansowane zapytania z klauzulami WHERE, AND, OR itd. Na początek stwórzmy plik „pobieranie.py„.

# -*- coding: utf-8 -*-
from sqlalchemy import *

# Użyjmy tej samej bazy danych
db = create_engine('sqlite:///przyklad.db')

db.echo = True  # Robimy true, żeby widzieć co się dzieje

metadata = MetaData(db)

# Tabela users istnieje, ładujemy ją z bazy danych za pomocą "autoload"
users = Table('users', metadata, autoload=True)

def run(stmt):
    rs = stmt.execute()
    for row in rs:
        print row


# Zapytanie z  warunkiem jednego pola
q = users.select(users.c.name == 'Ola')
run(q)
q = users.select(users.c.id > 1 )
run(q)
q = users.select(users.c.job == 'Handlowiec'

# AND, OR i NOT
q = users.select(and_(users.c.id < 3, users.c.name != 'Jan'))
run(q)
q = users.select(or_(users.c.id > 1 , users.c.name != 'Jan'))
run(q)
q = users.select(not_(users.c.name == 'Jan'))
run(q)

# równie dobrze możemy korzystać z &, | i ~
q = users.select((users.c.job == 'Handlowiec') & (users.c.name != 'Ola'))
run(q)
q = users.select((users.c.job == 'Handlowiec' | (users.c.name != 'Kuba'))
run(q)
q = users.select(~(users.c.name == 'Michal'))
run(q)

# dostępne są również funkcje "like", "startswith", "endswith"
q = users.select(users.c.name.startswith('K'))
run(q)
q = users.select(users.c.name.like('%a%'))
run(q)
q = users.select(users.c.name.endswith('a'))
run(q)

# ponadto dostępne są "in" i "between"
q = users.select(users.c.id.between(1,3))
run(q)

# aby zapobiec konfliktowi z pythonem dajemy in_
q = users.select(users.c.name.in_('Jan', 'Ola'))
run(q)

# do wywoływanie funkcji SQL służy "func"
q = users.select(func.substr(users.c.name, 3, 1) == 'b')
run(q)

# pobieranie określonych 
q = select([users], users.c.job != 'Handlowiec')
run(q)
q = select([users.c.name, users.c.job], users.c.name != 'Michal')
run(q)

# korzystanie z funkcji SQL  "count"
q = select([func.count(users.c.user_id)])
run(q)

# korzystanie z funkcji SQL  "count", żeby zliczyć wszystko
q = select([func.count("*")], from_obj=[users])
run(q)

Order By, Limit i inne takie

Pobierając dane z bazy, zazwyczaj chcemy żeby były one odpowiednio posortowane. W takich przypadkach z pomocą przychodzą do nas Order by, Limit itp.

# -*- coding: utf-8 -*-
from sqlalchemy import *

# Użyjmy tej samej bazy danych
db = create_engine('sqlite:///przyklad.db')

db.echo = True  # Robimy true, żeby widzieć co się dzieje

metadata = MetaData(db)

# Tabela users istnieje, ładujemy ją z bazy danych za pomocą "autoload"
users = Table('users', metadata, autoload=True)

def run(stmt):
    rs = stmt.execute()
    for row in rs:
        print row

# proste wykorzystanie order_by
q = users.select(order_by=[users.c.name])
run(q)

# malejące sortowanie na podstawie id
q = users.select(order_by=[desc(users.c.user_id)])
run(q)

# rosnące sortowanie na podstawie id
q = users.select(order_by=[desc(users.c.user_id)])
run(q)

# sortowanie na wielu kolumnach
q = users.select(users.c.job>'A', order_by=[desc(users.c.user_id), asc(users.c.job)])

# pobieranie unikalnych danych
q = select([users.c.name], distinct=True)
run(q)

# wykorzystanie limit i offset
q = users.select(offset=2, limit=2)
run(q)

Delete

Czasami nie tylko chcemy pobierać dane, ale chcemy je usuwać. Tu z pomocą wkracza obiekt delete().

# -*- coding: utf-8 -*-
from sqlalchemy import *

# Użyjmy tej samej bazy danych
db = create_engine('sqlite:///przyklad.db')

db.echo = True  # Robimy true, żeby widzieć co się dzieje

metadata = MetaData(db)

# Tabela users istnieje, ładujemy ją z bazy danych za pomocą "autoload"
users = Table('users', metadata, autoload=True)

def run(stmt):
    stmt.execute()

# Usuwamy rekord o id równym 1
q = users.delete(users.c.user_id == 1)
run(q)

# Usuwamy rekordy gdzie zawodem jest "Handlowiec"
q = users.delete(users.c.job == 'Handlowiec')
run(q)

# Usuwanie rekordów dla wielu argumentów
users.delete().execute(
		{'name': '%Jan%'},
		{'name': '%Ola%'},
		{'job': '%wozny%'}
	)

	

Update

Oprócz usuwania często chcemy coś poprawić lub zamienić w naszych rekordach. Pomoże nam w tym obiekt update().

# -*- coding: utf-8 -*-
from sqlalchemy import *

# Użyjmy tej samej bazy danych
db = create_engine('sqlite:///przyklad.db')

db.echo = True  # Robimy true, żeby widzieć co się dzieje

metadata = MetaData(db)

# Tabela users istnieje, ładujemy ją z bazy danych za pomocą "autoload"
users = Table('users', metadata, autoload=True)

# Podmieniamy "Kuba" na "Marcin"
users.update(users.c.user_name=='Kuba').execute(user_name='Marcin')

# Update dla wielu argumentów
users.update().execute(
        {'user_id':1, 'user_name':'Helena', 'job':'wozna'},
        {'user_id':2, 'user_name':'Zdzislaw', 'job':'ksiegowy'},
        {'user_id':3, 'user_name':'Maciek', 'job':'sportowiec'},
    )

JOIN czyli łączenie tabel

Wielokrotnie spotykamy się z problemem struktury bazy danych. Np. Trzymania w innej tabeli adresów zamieszkania naszych „userów”. Na początek stwórzmy sobie nowy plik „jointest.py” i wypełnij go poniższą zawartością:

# -*- coding: utf-8 -*-
from sqlalchemy import *

# Tworzymy nową bazę danych
db = create_engine('sqlite:///przykladjoin.db')

db.echo = True  # Robimy true, żeby widzieć co się dzieje

metadata = MetaData(db)

users = Table('users', metadata,
    Column('user_id', Integer, primary_key=True),
    Column('name', String(255)),
    Column('job', Integer),
    Column('pass', String(255)),
)

users.create() # Tworzymy tabelę users

address = Table('addresses', metadata,
	Column('address_id', Integer, primary_key=True),
	Column('town', String),
	Column('user_id', Integer, ForeignKey('users.user_id')),
	)

address.create() # Tworzymy tabelę address

insert = users.insert()
insert.execute(
			{'name': 'Jan', 'job': 'Handlowiec', 'pass': 'tajne'},
			{'name': 'Kuba', 'job': 'Wozny', 'pass': 'tajne'},
			{'name': 'Ola', 'job': 'Handlowiec', 'pass': 'tajne'},
			{'name': 'Karolina', 'job': 'Sportowiec', 'pass': 'tajne'},
			{'name': 'Marcin', 'job': 'Wozny', 'pass': 'tajne'}
		) # Wkładamy dane

insert = address.insert()
insert.execute(	
			{'town': 'Warsaw', 'user_id': 1},
			{'town': 'New York', 'user_id': 2},
			{'town': 'London', 'user_id': 3},
			{'town': 'Oslo', 'user_id': 4}
		) # Wkładamy dane


def run(stmt):
    rs = stmt.execute()
    for row in rs:
        print row	
	
# Spróbujmy trochę nabroić i zróbmy pełny join (:
# ze względu na brak klauzuli WHERE
# program zwróci nam wszystkie możliwe kombinacje rekordów.
q = select([users, address])	
run(q)

# Teraz spróbujemy z klauzulą WHERE 
# SQL: bla bla WHERE addresses.user_id = users.user_id
q = select([users, address], address.c.user_id == users.c.user_id)
run(q)

# Pobieramy tylko kilka kolumn
q = select([users.c.name, address.c.town], address.c.user_id == users.c.user_id)
run(q)

# sqlalchemy oferuje "mądry" obiekt "join"
# który określa odpowiednie parametry łączenia
# na podstawie "foreign keys" tabel
q = join(users, address).select()
run(q)

# jeżeli chcemy pobrać wszystkich userów
# nawet jeżeli nie mają wpisanego miasta
# to korzystamy z outerjoin w takiej kolejności 
q = outerjoin(users, address).select()
run(q)

# kolejność ma znaczenie
# domyślnie outerjoin jest "left outer join" 
# to znaczy tabela po lewej i odpowiadające jej wartości z tabeli po prawej
# w ten sposób nie pobierzemy rekordu z "Marcinem"
# ponieważ nie ma jego id w tabeli addresses
q = outerjoin(address, users).select()
run(q)

i wykonaj takie polecenie:

python jointest.py

Obiekt bindparam()

W SQLAlchemy możesz sam „zbindować„(określić) inną nazwę dla istniejącej nazwy jakiejś kolumny i korzystać z takiego „binda” wielokrotnie w swoich zapytaniach do bazy. Brzmi to strasznie, ale wytłumaczenie tego słowami ( przynajmniej dla mnie ) jest stosunkowo trudne, dlatego zapraszam do zajrzenia do kodu:

q = users.select(users.c.name==bindparam('username'))
conn.execute(q, username = 'Jan').fetchall() 

q = users.select(users.c.user_id==bindparam('id'))
conn.execute(q, id = 1 ).fetchall() 

Mam nadzieję, że jakoś to pojęliście (: Dokumentacja


Union

Union służy do łączenia wyników selectów ( nie pokaże powtarzających się wierszy ):

# -*- coding: utf-8 -*-
from sqlalchemy import *

# Użyjmy tej samej bazy danych
db = create_engine('sqlite:///przykladjoin.db')

db.echo = True  # Robimy true, żeby widzieć co się dzieje

metadata = MetaData(db)

# Tabela users istnieje, ładujemy ją z bazy danych za pomocą "autoload"
users = Table('users', metadata, autoload=True)
address = Table('addresses', metadata, autoload=True)

union(
    address.select(address.c.street=='New York'),
    address.select(address.c.street=='Oslo'),
    address.select(address.c.street=='Warsaw'),
    order_by=[addresses.c.street]
).execute()

users.select(
    users.c.user_id==1
  ).union_all(
      users.select(
          users.c.user_id==3
      ), 
      order_by=[users.c.user_id]
  ).execute()

Podsumowanie

SQLAlchemy to narzędzie proste, szybkie i wygodne, przyspieszające pracę programisty, który nie musi się już zamartwiać długimi zapytaniami z JOIN itp. Zdecydowanie POLECAM!( zwłaszcza do pracy z Pylonsem )


Źródła wiedzy