SQLAlchemy

SQLAlchemy

Stable release	0.6.6 / January 8, 2011 (2011-01-08)
Repository	github.com/sqlalchemy/sqlalchemy
Written in	Python
Operating system	Cross-platform
Type	Object-relational mapping
License	MIT License
Website	http://www.sqlalchemy.org/

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

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 SQL databases behave less and less like object collections the more size and performance start to matter, while object collections behave less and less like tables and rows the more abstraction starts to matter. For this reason it has adopted the Data Mapper pattern (like Hibernate for Java) rather than the active record pattern used by a number of other object-relational mappers. However, optional plugins such as Elixir and declarative allow users to develop using declarative syntax.

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.

Example

The following example represents an n-to-1 relationship between movies and their directors. It is shown how user defined Python classes create according 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(Base):
    __tablename__ = 'movies'
 
    id = Column(Integer, primary_key=True)
    title = Column(String(255), nullable=False)
    year = Column(Integer)
    directed_by = Column(Integer, ForeignKey('directors.id'))
 
    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):
        self.name = name
 
    def __repr__(self):
        return "Director(%r)" % (self.name)
 
engine = create_engine('dbms://user:pwd@host/dbname')
Base.metadata.create_all(engine)

Data insertion

Inserting movies and their directors can be achieved via both entities:

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

m1 = Movie("Star Trek", 2009)
m1.director = Director("JJ Abrams")

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

try:
    session.add(m1)
    session.add(d2)
    session.commit()
except:
    session.rollback()

Querying

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

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

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('Star Trek', 2009L, Director('JJ Abrams'))
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.id, movies.title, movies.year, movies.directed_by 
FROM movies

SELECT directors.id, directors.name
FROM directors 
WHERE directors.id = %s

References

• Gift, Noah (12 Aug 2008). "Using SQLAlchemy". Developerworks. IBM. Retrieved 08 Feb 2011. {{cite web}}: Check date values in: |accessdate= (help)
• Rick Copeland, Essential SQLAlchemy, O'Reilly, 2008, ISBN 0-596-51614-2

See also

• SQLObject
• Storm
• Pylons
• TurboGears
• Django

External links

• SQLAlchemy home page