SQLAlchemy


SQLAlchemy is an open-source SQL toolkit and object-relational mapper for the Python programming language released under the MIT License.

Description

SQLAlchemy's philosophy is that relational databases behave less like object collections as the scale gets larger and performance starts being a concern, while object collections behave less like tables and rows as more abstraction is designed into them. For this reason it has adopted the data mapper pattern rather than the active record pattern used by a number of other object-relational mappers. However, optional plugins allow users to develop using declarative syntax.

History

SQLAlchemy was first released in February 2006 and has quickly become one of the most widely used object-relational mapping tools in the Python community, alongside Django's ORM.

Example

The following example represents an n-to-1 relationship between movies and their directors. It is shown how user-defined Python classes create corresponding database tables, how instances with relationships are created from either side of the relationship, and finally how the data can be queried—illustrating automatically-generated SQL queries for both lazy and eager loading.

Schema definition

Creating two Python classes and according database tables in the DBMS:

from sqlalchemy import *
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import relation, sessionmaker
Base = declarative_base
class Movie:
__tablename__ = 'movies'
id = Column
title = Column
year = Column
directed_by = Column
director = relation
def __init__:
self.title = title
self.year = year
def __repr__:
return "Movie" %
class Director:
__tablename__ = 'directors'
id = Column
name = Column
def __init__:
self.name = name
def __repr__:
return "Director" %
engine = create_engine
Base.metadata.create_all

Data insertion

One can insert a director-movie relationship via either entity:

Session = sessionmaker
session = Session
m1 = Movie
m1.director = Director
d2 = Director
d2.movies =
try:
session.add
session.add
session.commit
except:
session.rollback

Querying


alldata = session.query.all
for somedata in alldata:
print somedata

SQLAlchemy issues the following query to the DBMS :

SELECT movies.id, movies.title, movies.year, movies.directed_by, directors.id, directors.name
FROM movies LEFT OUTER JOIN directors ON directors.id = movies.directed_by

The output:

Movie
Movie
Movie

Setting lazy=True instead, SQLAlchemy would first issue a query to get the list of movies and only when needed for each director a query to get the name of the according director:

SELECT movies.id, movies.title, movies.year, movies.directed_by
FROM movies
SELECT directors.id, directors.name
FROM directors
WHERE directors.id = %s