对象炼金术 - SQLAlchemy 多外键关联同一实体类

    继续上节 SQLAlchemy 外键的探索.
    假设现在需求改变了, 需要给每个 Album 加个字段表示作词者, 而作词者本身也应是 Artist 的实例 (比如很多演唱者会自己为歌曲作词编曲等等), 这时 Album 会有超过一个关联到 Artist 的外键.
    如果仅仅简单如下处理

class Album(Base):
    __tablename__ = 'album'
    album_id = sqla.Column('id', sqla.Integer, primary_key=True)
    name = sqla.Column('name', sqla.String)
    artist_id = sqla.Column('artist', sqla.ForeignKey('artist.id'))
    artist = sqlorm.relationship(
          Artist,
          backref=sqlorm.backref('albums', cascade='all,delete-orphan'))
    lyricist_id = sqla.Column('lyricist', sqla.ForeignKey('artist.id'))
    lyricist = sqlorm.relationship(
          Artist,
          backref=sqlorm.backref('written_albums', cascade='all,delete-orphan'))

然后添加一点数据进去

def save():
    artist0 = Artist(name='aki misawa')
    artist1 = Artist(name='katou emiri')
    artist2 = Artist(name='yamada hirosi')
    album0 = Album(name='stella musica', artist=artist0, lyricist=artist0)
    album1 = Album(name='hoshikage no ama no hara', artist=artist0,
                   lyricist=artist0)
    album2 = Album(name='jump!', artist=artist1, lyricist=artist2)
    session = Session()
    try:
        session.add(album0)
        session.add(album1)
        session.add(album2)
        session.flush()
        session.commit()
    finally:
        session.close()

if __name__ == '__main__':
    save()

结果运行立即悲剧, SQLAlchemy 会报下面的错误

sqlalchemy.exc.ArgumentError: Could not determine join condition between parent/child tables on relationship Album.artist. Specify a 'primaryjoin' expression.  If 'secondary' is present, 'secondaryjoin' is needed as well.

也许这是 SQLAlchemy 的问题, 明明这么明了的外键关系咋就跪了呢.

好吧, 简单的正确答案是, 手动配置一下外键的 primaryjoin 属性, 如下

Posted at Mar 14 2012 - 03:44:02

Permanent Link: /p/488 Load full text

Post tags:

ORM
SQLAlchemy
Python
Tutorial

对象炼金术 - SQLAlchemy 中关系的级联

在上一节中谈到了如何把有关联的对象一起塞进数据表中, 现在来试试从数据表里面取出一条数据然后删掉.
在之前代码的基础上添加下面的函数

def remove_album(name):
    session = Session()
    try:
        for a in session.query(Album).filter(Album.name == name).all():
            session.delete(a)
        session.flush()
        session.commit()
    finally:
        session.close()

在这个函数中, 查询 Album 类型, 然后调用查询对象的 filter 函数, 指定列 name 的值严格等于该 name 参数. 接下来, 将查询得到的对象逐个删除.
来看看搞起来如何

if __name__ == '__main__':
    save()
    remove_album('stella musica')
    list_all()

嗯, 看起来还不错的样子.

那么, 接下来试试删 Artist

def remove_artist(name):
    session = Session()
    try:
        for a in session.query(Artist).filter(Artist.name == name).all():
            session.delete(a)
        session.flush()
        session.commit()
    finally:
        session.close()

if __name__ == '__main__':
    save()
    remove_artist('katou emiri')
    list_all()

于是乎就悲剧了.
崩盘之前的几行输出似乎是这样子的

= Albums =
stella musica
+ Artist: aki misawa
hoshikage no ama no hara
+ Artist: aki misawa
jump!
+ Artist:

也就是说, remove_artist 确实从数据库中删去了名字为 'katou emiri' 的那个值, 因此名为 'jump!' 的那个 Album 实例的 artist 域成了 None, 悲剧就发生了.

要解决这个问题, 就得在 Album 与 Artist 的关联关系上动动手脚, 加上级联信息.

Posted at Mar 13 2012 - 04:44:15

Permanent Link: /p/487 Load full text

Post tags:

SQLAlchemy
ORM
Python
Tutorial

对象炼金术 - SQLAlchemy 从外键到关系

上节回顾, 使用下面这样的代码保存一个 Artist 与一个 Album, 两条 flush 令人感觉相当不适.

def save():
    artist = Artist(name='aki misawa')
    session = Session()
    try:
        session.add(artist)
        session.flush() # 0
        album = Album(name='stella musica', artist_id=artist.artist_id)
        session.add(album)
        session.flush() # 1
        session.commit()
    finally:
        session.close()

单纯一个外键还不能很直观地解决对象之间的关联关系. 下面就引入 sqlalchemy.orm.relationship 来改善这块代码.

import sqlalchemy as sqla
import sqlalchemy.orm as sqlorm
from sqlalchemy.ext.declarative import declarative_base as sqla_declarative_base

Base = sqla_declarative_base()
# use MEMORY, not a database file.
# and disable SQL echo
engine = sqla.create_engine('sqlite:///:memory:', echo=False)

class Artist(Base):
    __tablename__ = 'artist'
    artist_id = sqla.Column('id', sqla.Integer, primary_key=True)
    name = sqla.Column('name', sqla.String)

class Album(Base):
    __tablename__ = 'album'
    album_id = sqla.Column('id', sqla.Integer, primary_key=True)
    name = sqla.Column('name', sqla.String)
    artist_id = sqla.Column('artist', sqla.ForeignKey('artist.id'))

    artist = sqlorm.relationship(Artist)

在类 Artist 与 Album 定义完成后, 再用 relationship 为 Album 补上一个类成员, 表示它与 Artist 之间的关系.

这样一来, SQLAlchemy 就能根据此 relationship, 从对象关系中产生外键值, 比如之前的 save 函数可以变成这个样子

Session = sqlorm.scoped_session(sqlorm.sessionmaker(bind=engine))

def save():
    artist = Artist(name='aki misawa')
    album = Album(name='stella musica', artist=artist)
    session = Session()
    try:
        session.add(album)
        session.flush()
        session.commit()
    finally:
        session.close()

Posted at Mar 12 2012 - 08:31:04

Permanent Link: /p/486 Load full text

Post tags:

SQLAlchemy
Python
ORM
Tutorial

对象炼金术 - 体验 SQLAlchemy

一直听说 SQLAlchemy 是个神一般的 ORM, 近期终于忍不住打算搞一搞, 还是小有收获的, 写一点出来, 欢迎大家来搞.
本文中的例子都是基于 Python 2.7, SQLAlchemy 0.7 的. 数据库使用 SQLite.

废话少说, 先来一段代码

import sqlalchemy as sqla
import sqlalchemy.orm as sqlorm
from sqlalchemy.ext.declarative import declarative_base as sqla_declarative_base

Base = sqla_declarative_base()
engine = sqla.create_engine('sqlite:///test.db', echo=True)

class Artist(Base):
    __tablename__ = 'artist'
    artist_id = sqla.Column('id', sqla.Integer, primary_key=True)
    name = sqla.Column('name', sqla.String)

Base.metadata.bind = engine
Base.metadata.create_all()

Session = sqlorm.scoped_session(sqlorm.sessionmaker(bind=engine))

def save_artist():
    artist = Artist(name='aki misawa')
    session = Session()
    try:
        session.add(artist)
        session.flush()
        print 'Artist id:', artist.artist_id
        session.commit()
    finally:
        session.close()

if __name__ == '__main__':
    save_artist()

运行这一段代码将会在当前目录创建 test.db 文件作为数据文件, 同时建立一个 Artist 表, 其中有主键字段 artist_id 跟表示名字的字符串列 name. 然后向这个表中插入一个对象, 并输出这个 artist 的 artist_id
在这一行

Base = sqla_declarative_base()

产生了 SQLAlchemy 中用于构造表的基类. 而接下来 create_engine 调用则绑定数据库以及文件, 并设置回显 SQL.

然后重头来了, 声明类型 Artist

class Artist(Base):
    __tablename__ = 'artist'
    artist_id = sqla.Column('id', sqla.Integer, primary_key=True)
    name = sqla.Column('name', sqla.String)

以及类成员 __tablename__ 表示表名, 接着以整数类型声明主键, 以及另一列 name 为字符串类型. 不用 varchar 真心舒畅.

接着两句

Base.metadata.bind = engine
Base.metadata.create_all()

则是在数据库中建立表. 如果已经建立 (譬如第二次运行这个例子), 删去这两句似乎也没问题.
虽然没看 SQLAlchemy 的实现, 但是构建 Base 类, 以及调用 create_all 建表有点多此一举的感觉. 我还是比较喜欢 GAE 存储那种直白的风格.

后面的

Session = sqlorm.scoped_session(sqlorm.sessionmaker(bind=engine))

Posted at Mar 09 2012 - 13:46:26

Permanent Link: /p/485 Load full text

Post tags:

ORM
SQLAlchemy
Python
Tutorial

django 架设网站入门指南[壹]

上节回顾 – 配置基本视图和逻辑

数据库配置

仍然在 settings.py 中, 找到 DATABASE_ 开头的项目. 现在用 sqlite3 作为数据库, 它已经集成在 python 2.5 以后的版本中, 这样就省去了安装配置的环节. 现在修改这些项目

DATABASE_ENGINE = 'django.db.backends.sqlite3'
DATABASE_NAME = 'guestbook/db_file'

这里 DATABASE_NAME 同样需要给出文件的绝对路径, 原理跟之前模板目录那个一样, 如果不能确定每次的工作目录, 那么就填绝对 db_file 的路径吧. 保存设置, 然后执行数据库同步操作
$ guestbook/manage.py syncdb
会输出提示

Creating table auth_permission
Creating table auth_group
Creating table auth_user
Creating table auth_message
Creating table django_content_type
Creating table django_session
Creating table django_site

You just installed Django's auth system, which means you don't have any superusers defined.
Would you like to create one now? (yes/no):

这些是 django 为内置的用户, 会话等类型建立的表, 最后询问是否立即建立一个超级用户. 这里答 yes (仅一个 y 是不行的唉), 然后输入用户名, 电子邮箱和密码. 最后会建立表的索引, 然后结束. 现在, 你可以在 guestbook 目录下看到文件 db_file 了, 它是数据库使用的文件.

ORM 和数据库操作

django 的 ORM 非常轻松. 打开 home 目录下的 models.py, 建立留言类型

from django.db import models

class Message(models.Model):
    name = models.CharField(max_length=32)
    content = models.CharField(max_length=32)
    dt = models.DateTimeField(auto_now=True)

注, 使用 django 的 ORM, 该类型需要继承于 models.Model, 而要往数据库中放的数据项, 需要是 models 模块中的对应的域类型. 至于 auto_now=True, 它指出时间和日期在该对象插入数据库时自动使用当前日期时间.
类型弄好了, 得再同步一次数据库. 这些操作可以不重启服务器

$ guestbook/manage.py sql home
$ guestbook/manage.py syncdb

回到 guestbook/home/views.py, 增加函数 save_message, 让它将表单数据存入数据库, 并重定向回到首页

Posted at Feb 03 2010 - 14:09:53

Permanent Link: /p/76 Load full text

Post tags:

Web Server
Tutorial
Python
django
ORM

对象炼金术 - SQLAlchemy 多外键关联同一实体类继续上节 SQLAlchemy 外键的探索. 假设现在需求改变了, 需要给每个 `Album` 加个字段表示作词者, 而作词者本身也应是 `Artist` 的实例 (比如很多演唱者会自己为歌曲作词编曲等等), 这时 `Album` 会有超过一个关联到 `Artist` 的外键. 如果仅仅简单如下处理 class Album(Base): __tablename__ = 'album' album_id = sqla.Column('id', sqla.Integer, primary_key=True) name = sqla.Column('name', sqla.String) artist_id = sqla.Column('artist', sqla.ForeignKey('artist.id')) artist = sqlorm.relationship( Artist, backref=sqlorm.backref('albums', cascade='all,delete-orphan')) lyricist_id = sqla.Column('lyricist', sqla.ForeignKey('artist.id')) lyricist = sqlorm.relationship( Artist, backref=sqlorm.backref('written_albums', cascade='all,delete-orphan')) 然后添加一点数据进去 def save(): artist0 = Artist(name='aki misawa') artist1 = Artist(name='katou emiri') artist2 = Artist(name='yamada hirosi') album0 = Album(name='stella musica', artist=artist0, lyricist=artist0) album1 = Album(name='hoshikage no ama no hara', artist=artist0, lyricist=artist0) album2 = Album(name='jump!', artist=artist1, lyricist=artist2) session = Session() try: session.add(album0) session.add(album1) session.add(album2) session.flush() session.commit() finally: session.close() if __name__ == '__main__': save() 结果运行立即悲剧, SQLAlchemy 会报下面的错误 `sqlalchemy.exc.ArgumentError: Could not determine join condition between parent/child tables on relationship Album.artist. Specify a 'primaryjoin' expression. If 'secondary' is present, 'secondaryjoin' is needed as well.` 也许这是 SQLAlchemy 的问题, 明明这么明了的外键关系咋就跪了呢. 好吧, 简单的正确答案是, 手动配置一下外键的 `primaryjoin` 属性, 如下 Posted at Mar 14 2012 - 03:44:02 Permanent Link: /p/488 Load full text	Post tags: ORM SQLAlchemy Python Tutorial
对象炼金术 - SQLAlchemy 中关系的级联在上一节中谈到了如何把有关联的对象一起塞进数据表中, 现在来试试从数据表里面取出一条数据然后删掉. 在之前代码的基础上添加下面的函数 `def remove_album(name): session = Session() try: for a in session.query(Album).filter(Album.name == name).all(): session.delete(a) session.flush() session.commit() finally: session.close()` 在这个函数中, 查询 `Album` 类型, 然后调用查询对象的 `filter` 函数, 指定列 `name` 的值严格等于该 `name` 参数. 接下来, 将查询得到的对象逐个删除. 来看看搞起来如何 `if __name__ == '__main__': save() remove_album('stella musica') list_all()` 嗯, 看起来还不错的样子. 那么, 接下来试试删 `Artist` `def remove_artist(name): session = Session() try: for a in session.query(Artist).filter(Artist.name == name).all(): session.delete(a) session.flush() session.commit() finally: session.close() if __name__ == '__main__': save() remove_artist('katou emiri') list_all()` 于是乎就悲剧了. 崩盘之前的几行输出似乎是这样子的 `= Albums = stella musica + Artist: aki misawa hoshikage no ama no hara + Artist: aki misawa jump! + Artist:` 也就是说, `remove_artist` 确实从数据库中删去了名字为 `'katou emiri'` 的那个值, 因此名为 `'jump!'` 的那个 `Album` 实例的 `artist` 域成了 `None`, 悲剧就发生了. 要解决这个问题, 就得在 `Album` 与 `Artist` 的关联关系上动动手脚, 加上级联信息. Posted at Mar 13 2012 - 04:44:15 Permanent Link: /p/487 Load full text	Post tags: SQLAlchemy ORM Python Tutorial
对象炼金术 - SQLAlchemy 从外键到关系上节回顾, 使用下面这样的代码保存一个 `Artist` 与一个 `Album`, 两条 `flush` 令人感觉相当不适. `def save(): artist = Artist(name='aki misawa') session = Session() try: session.add(artist) session.flush() # 0 album = Album(name='stella musica', artist_id=artist.artist_id) session.add(album) session.flush() # 1 session.commit() finally: session.close()` 单纯一个外键还不能很直观地解决对象之间的关联关系. 下面就引入 `sqlalchemy.orm.relationship` 来改善这块代码. import sqlalchemy as sqla import sqlalchemy.orm as sqlorm from sqlalchemy.ext.declarative import declarative_base as sqla_declarative_base Base = sqla_declarative_base() # use MEMORY, not a database file. # and disable SQL echo engine = sqla.create_engine('sqlite:///:memory:', echo=False) class Artist(Base): __tablename__ = 'artist' artist_id = sqla.Column('id', sqla.Integer, primary_key=True) name = sqla.Column('name', sqla.String) class Album(Base): __tablename__ = 'album' album_id = sqla.Column('id', sqla.Integer, primary_key=True) name = sqla.Column('name', sqla.String) artist_id = sqla.Column('artist', sqla.ForeignKey('artist.id')) artist = sqlorm.relationship(Artist) 在类 `Artist` 与 `Album` 定义完成后, 再用 `relationship` 为 `Album` 补上一个类成员, 表示它与 `Artist` 之间的关系. 这样一来, SQLAlchemy 就能根据此 `relationship`, 从对象关系中产生外键值, 比如之前的 `save` 函数可以变成这个样子 `Session = sqlorm.scoped_session(sqlorm.sessionmaker(bind=engine)) def save(): artist = Artist(name='aki misawa') album = Album(name='stella musica', artist=artist) session = Session() try: session.add(album) session.flush() session.commit() finally: session.close()` Posted at Mar 12 2012 - 08:31:04 Permanent Link: /p/486 Load full text	Post tags: SQLAlchemy Python ORM Tutorial
对象炼金术 - 体验 SQLAlchemy 一直听说 SQLAlchemy 是个神一般的 ORM, 近期终于忍不住打算搞一搞, 还是小有收获的, 写一点出来, 欢迎大家来搞. 本文中的例子都是基于 Python 2.7, SQLAlchemy 0.7 的. 数据库使用 SQLite. 废话少说, 先来一段代码 import sqlalchemy as sqla import sqlalchemy.orm as sqlorm from sqlalchemy.ext.declarative import declarative_base as sqla_declarative_base Base = sqla_declarative_base() engine = sqla.create_engine('sqlite:///test.db', echo=True) class Artist(Base): __tablename__ = 'artist' artist_id = sqla.Column('id', sqla.Integer, primary_key=True) name = sqla.Column('name', sqla.String) Base.metadata.bind = engine Base.metadata.create_all() Session = sqlorm.scoped_session(sqlorm.sessionmaker(bind=engine)) def save_artist(): artist = Artist(name='aki misawa') session = Session() try: session.add(artist) session.flush() print 'Artist id:', artist.artist_id session.commit() finally: session.close() if __name__ == '__main__': save_artist() 运行这一段代码将会在当前目录创建 test.db 文件作为数据文件, 同时建立一个 Artist 表, 其中有主键字段 artist_id 跟表示名字的字符串列 name. 然后向这个表中插入一个对象, 并输出这个 `artist` 的 `artist_id` 在这一行 `Base = sqla_declarative_base()` 产生了 SQLAlchemy 中用于构造表的基类. 而接下来 `create_engine` 调用则绑定数据库以及文件, 并设置回显 SQL. 然后重头来了, 声明类型 `Artist` `class Artist(Base): __tablename__ = 'artist' artist_id = sqla.Column('id', sqla.Integer, primary_key=True) name = sqla.Column('name', sqla.String)` 以及类成员 `__tablename__` 表示表名, 接着以整数类型声明主键, 以及另一列 `name` 为字符串类型. 不用 `varchar` 真心舒畅. 接着两句 `Base.metadata.bind = engine Base.metadata.create_all()` 则是在数据库中建立表. 如果已经建立 (譬如第二次运行这个例子), 删去这两句似乎也没问题. 虽然没看 SQLAlchemy 的实现, 但是构建 `Base` 类, 以及调用 `create_all` 建表有点多此一举的感觉. 我还是比较喜欢 GAE 存储那种直白的风格. 后面的 `Session = sqlorm.scoped_session(sqlorm.sessionmaker(bind=engine))` Posted at Mar 09 2012 - 13:46:26 Permanent Link: /p/485 Load full text	Post tags: ORM SQLAlchemy Python Tutorial
django 架设网站入门指南[壹] 上节回顾 – 配置基本视图和逻辑数据库配置仍然在 settings.py 中, 找到 `DATABASE_` 开头的项目. 现在用 sqlite3 作为数据库, 它已经集成在 python 2.5 以后的版本中, 这样就省去了安装配置的环节. 现在修改这些项目 `DATABASE_ENGINE = 'django.db.backends.sqlite3' DATABASE_NAME = 'guestbook/db_file'` 这里 `DATABASE_NAME` 同样需要给出文件的绝对路径, 原理跟之前模板目录那个一样, 如果不能确定每次的工作目录, 那么就填绝对 db_file 的路径吧. 保存设置, 然后执行数据库同步操作 `$ guestbook/manage.py syncdb` 会输出提示 `Creating table auth_permission Creating table auth_group Creating table auth_user Creating table auth_message Creating table django_content_type Creating table django_session Creating table django_site You just installed Django's auth system, which means you don't have any superusers defined. Would you like to create one now? (yes/no):` 这些是 django 为内置的用户, 会话等类型建立的表, 最后询问是否立即建立一个超级用户. 这里答 yes (仅一个 y 是不行的唉), 然后输入用户名, 电子邮箱和密码. 最后会建立表的索引, 然后结束. 现在, 你可以在 guestbook 目录下看到文件 db_file 了, 它是数据库使用的文件. ORM 和数据库操作 django 的 ORM 非常轻松. 打开 home 目录下的 models.py, 建立留言类型 `from django.db import models class Message(models.Model): name = models.CharField(max_length=32) content = models.CharField(max_length=32) dt = models.DateTimeField(auto_now=True)` 注, 使用 django 的 ORM, 该类型需要继承于 `models.Model`, 而要往数据库中放的数据项, 需要是 models 模块中的对应的域类型. 至于 `auto_now=True`, 它指出时间和日期在该对象插入数据库时自动使用当前日期时间. 类型弄好了, 得再同步一次数据库. 这些操作可以不重启服务器 `$ guestbook/manage.py sql home $ guestbook/manage.py syncdb` 回到 guestbook/home/views.py, 增加函数 `save_message`, 让它将表单数据存入数据库, 并重定向回到首页 Posted at Feb 03 2010 - 14:09:53 Permanent Link: /p/76 Load full text	Post tags: Web Server Tutorial Python django ORM

	Back to Bit Focus
	NijiPress - Copyright (C) Neuron Teckid @ Bit Focus
	About this site

Bit Focus

数据库配置

ORM 和数据库操作