Open main menu

Wikipedia β

SQLAlchemy is an open source SQL toolkit and object-relational mapper (ORM) for the Python programming language released under the MIT License.[4]

Original author(s) Michael Bayer[1]
Initial release February 14, 2006; 12 years ago (2006-02-14)[2]
Stable release
1.2.8 / May 28, 2018; 2 months ago (2018-05-28)[3]
Preview release
Repository Edit this at Wikidata
Written in Python
Operating system Cross-platform
Type Object-relational mapping
License MIT License[4]
Mike Bayer talking about SQLAlchemy at PyCon 2012

SQLAlchemy provides "a full suite of well known enterprise-level persistence patterns, designed for efficient and high-performing database access, adapted into a simple and Pythonic domain language". SQLAlchemy's philosophy is that relational databases behave less like object collections the more that scale and performance are concerns, while conversely, object collections behave less like tables and rows the more abstraction is a primary factor in the design. For this reason it has adopted the data mapper pattern (similar to Hibernate for Java) rather than the active record pattern used by a number of other object-relational mappers.[5] However, optional plugins allow users to develop using declarative syntax.[6]

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



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 definitionEdit

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(Base):
    __tablename__ = 'movies'

    id = Column(Integer, primary_key=True)
    title = Column(String(255), nullable=False)
    year = Column(Integer)
    directed_by = Column(Integer, ForeignKey(''))

    director = relation("Director", backref='movies', lazy=False)

    def __init__(self, title=None, year=None):
        self.title = title
        self.year = year

    def __repr__(self):
        return "Movie(%r, %r, %r)" % (self.title, self.year, self.director)

class Director(Base):
    __tablename__ = 'directors'

    id = Column(Integer, primary_key=True)
    name = Column(String(50), nullable=False, unique=True)

    def __init__(self, name=None): = name

    def __repr__(self):
        return "Director(%r)" % (

engine = create_engine('dbms://user:pwd@host/dbname')

Data insertionEdit

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

Session = sessionmaker(bind=engine)
session = Session()

m1 = Movie("Robocop", 1987)
m1.director = Director("Paul Verhoeven")

d2 = Director("George Lucas")
d2.movies = [Movie("Star Wars", 1977), Movie("THX 1138", 1971)]



alldata = session.query(Movie).all()
for somedata in alldata:
    print somedata

SQLAlchemy issues the following query to the DBMS (omitting aliases):

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

The output:

Movie('Robocop', 1987L, Director('Paul Verhoeven'))
Movie('Star Wars', 1977L, Director('George Lucas'))
Movie('THX 1138', 1971L, Director('George Lucas'))

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

SELECT, movies.title, movies.year, movies.directed_by
FROM movies

FROM directors
WHERE = %s

See alsoEdit



External linksEdit