Python的数据库ORM框架：SQLAlchemy

转 http://www.open-open.com/lib/view/open1357482850074.html

     http://wangye.org/blog/archives/721/

SQLAlchemy是Python编程语言下的一款开源软件。提供了SQL工具包及对象关系映射（ORM）工具，使用MIT许可证发行。

SQLAlchemy“采用简单的Python语言，为高效和高性能的数据库访问设计，实现了完整的企业级持久模型”。SQLAlchemy的理念是，SQL数据库的量级和性能重要于对象集合；而对象集合的抽象又重要于表和行。因此，SQLAlchmey采用了类似于Java里Hibernate的数据映射模型，而不是其他ORM框架采用的Active Record模型。不过，Elixir和declarative等可选插件可以让用户使用声明语法。

下面是一个完整ORM的例子:

[python]  view plain  copy

1. from sqlalchemy.orm import mapper, sessionmaker #sessionmaker() 函数是最常使用的创建最顶层可用于整个应用 Session 的方法,Session 管理着所有与数据库之间的会话  
2. from datetime import datetime  
3. from sqlalchemy import Table, MetaData, Column, ForeignKey, Integer, String, Unicode, DateTime #会SQL的人能理解这些函数吧?  
4. engine = create_engine("sqlite:///tutorial.db", echo=True) #创建到数据库的连接,echo=True 表示用logging输出调试结果  
5. metadata = MetaData() #跟踪表属性  
6. user_table = Table( #创建一个表所需的信息:字段,表名等  
7. 'tf_user', metadata,  
8. Column('id', Integer, primary_key=True),  
9. Column('user_name', Unicode(16), unique=True, nullable=False),  
10. Column('email_address', Unicode(255), unique=True, nullable=False),  
11. Column('password', Unicode(40), nullable=False),  
12. Column('first_name', Unicode(255), default=''),  
13. Column('last_name', Unicode(255), default=''),  
14. Column('created', DateTime, default=datetime.now))  
15. metadata.create_all(engine)  #在数据库中生成表  
16. class User(object): pass #创建一个映射类  
17. mapper(User, user_table) #把表映射到类  
18. Session = sessionmaker() #创建了一个自定义了的 Session类  
19. Session.configure(bind=engine)  #将创建的数据库连接关联到这个session  
20. session = Session()  
21. u = User()  
22. u.user_name='dongwm'  
23. u.email_address='dongwm@dongwm.com'  
24. u.password='testpass'  #给映射类添加以下必要的属性,因为上面创建表指定这几个字段不能为空  
25. session.add(u)  #在session中添加内容  
26. session.flush() #保存数据 session.commit() #数据库事务的提交,sisson自动过期而不需要关闭  
27. query = session.query(User) #query() 简单的理解就是select() 的支持 ORM 的替代方法,可以接受任意组合的 class/column 表达式 print list(query) #列出所有user print query.get(1) #根据主键显示 print query.filter_by(user_name='dongwm').first() #类似于SQL的where,打印其中的第一个 u = query.filter_by(user_name='dongwm').first() u.password = 'newpass' #修改其密码字段 session.commit() #提交事务 print query.get(1).password #打印会出现新密码  
28. for instance in session.query(User).order_by(User.id): #根据id字段排序,打印其中的用户  
29. print instance.user_name, instance.email_address  

Python数据库ORM SQLAlchemy 0.7学习笔记(2) 定义映射

昨天简单介绍了SQLAlchemy的使用，但是没有能够涉及其最精彩的ORM部分，今天我将简单说明一下，当然主要还是讲解官方文档的内容，由于是学习笔记，有可能存在精简或者自己理解的部分，不做权威依据。

当我们开始使用ORM，一种可配置的结构可以用于描述我们的数据库表，稍后我们定义的类将会被映射到这些表上。当然现代的SQLAlchemy（新版本SQLAlchemy，原文是modern SQLAlchemy）使用Declarative把这两件事一起做了，即允许我们把创建类和描述定义数据库表以及它们之间的映射关系一次搞定。

这段话是什么意思呢？简单来说吧，SQLAlchemy分为Classic (经典模式)和Modern (现代模式)，Classic定义数据库表的模式比较传统，需要先描述这个表。

1. Classic 映射

比如以官方文档中的例子，我们拥有表结构如下：

[python]  view plain  copy

1. CREATE TABLE [users] (  
2.   [id]       INTEGER PRIMARY KEY,  
3.   [name]     TEXT NOT NULL,  
4.   [fullname] TEXT NOT NULL,  
5.   [password] TEXT NOT NULL  
6. );  

下面我们描述这张表：

[python]  view plain  copy

1. from sqlalchemy import Table, MetaData, Column, Integer, String  
2.    
3. metadata = MetaData()  
4.    
5. user = Table('users', metadata,  
6.             Column('id', Integer, primary_key=True),  
7.             Column('name', String(50)),  
8.             Column('fullname', String(50)),  
9.             Column('password', String(12))  
10.         )  

好，这样我们的表算是描述完成了，接下来我们需要定义我们的Python类，比如这样的：

[python]  view plain  copy

1. class User(object):  
2.     def __init__(self, name, fullname, password):  
3.         self.name = name  
4.         self.fullname = fullname  
5.         self.password = password  

如何让我们定义的类与之前描述的表结构发生映射关系就是我们接下来要做的：

[python]  view plain  copy

1. from sqlalchemy.orm import mapper  
2. mapper(User, user)  

大家注意到mapper函数，第一个参数是我们类的名称，第二个参数是我们先前描述的表定义。
这就是传统的定义ORM的方法，有关这个方法的更多信息，可以阅读文档 Mapper Configuration ，以后有机会再和大家详谈。

2. Modern 映射

    当大家都乐此不疲的定义描述表，定义类，再映射来实现ORM的时候，SQLAlchemy团队搞出了更简单的映射方法，那就是Modern模式了，即通过定义映射类来一次性完成所有任务。

   为了定义的类能够被SQLAlchemy管理，所以引入了Declarative这个概念，也就是说我们所有的类必须是Declarative基类的子类，而这个基类可以通过下面的办法来获取：

[python]  view plain  copy

1. from sqlalchemy.ext.declarative import declarative_base  
2. Base = declarative_base()  

当然一个程序内，这个基类最好是唯一的，建议存储在全局变量比如Base中供所有映射类使用。

现在通过刚才的代码我们得到了名为Base的基类，通过这个基类我们可以定义N多的映射子类，而这些子类都能被SQLAlchemy Declarative系统管理到。

下面我们还是看刚才的那个users表的例子：

[python]  view plain  copy

1. from sqlalchemy import Column, Integer, String  
2. class User(Base):  
3.      __tablename__ = 'users'  
4.    
5.      id = Column(Integer, primary_key=True)  
6.      name = Column(String)  
7.      fullname = Column(String)  
8.      password = Column(String)  
9.    
10.      def __init__(self, name, fullname, password):  
11.          self.name = name  
12.          self.fullname = fullname  
13.          self.password = password  
14.    
15.      def __repr__(self):  
16.         return "<User('%s','%s', '%s')>" % (self.name, self.fullname, self.password)  

    就这段代码就完成了我们先前在Classic中需要的三步，代码比原先更简洁和容易管理了，同刚才Classic中Table定义的Column，这个代表数据库表中的列，当然Integer和String代表着数据库表的字段类型了。

这样User类就建立起与数据库表的映射，真实表的名字可以使用__tablename__指明，然后是表列的集合，包括id、name、fullname以及password，当然想必大家已经知道了，我们通过primary_key=True已经指明id为主键了。当然一些数据库表可能不包含有主键（例如视图View，当然视图也可以被映射），ORM为了能够实际映射表需要至少一个列被定义为主键列。多列，比如复合多主键也能够被很好地映射支持。

大家可能注意到User类中还包含有通常意义上的Python魔术方法，包含__init__()初始化类（构造方法）以及__repr__()字符串化支持方法，当然这些都是可选的，如果需要这个类可以加入程序所需要的任意多方法或者属性，你只要把这个类看作一个普通的Python类就可以了。

当然User类唯一不能马虎的就是必须继承至Base，这个Base就是刚才我们通过declarative_base()生成的类，通过它我们可以接下来让SQLAlchemy Declarative系统管理并操作这些映射类和数据库表。

实际上包括继承的Base类，所有的类都应该是Python的新式类(new style class)，关于新式类的更多信息可以参考Python手册。

 随着我们的User映射类通过Declarative系统构造成功，我们就拥有了相关的定义信息，比如在Classic定义中介绍的Table()描述，也包含映射到表的类，就是User自身，我们可以通过User.__table__来查看我们的表描述情况：

[python]  view plain  copy

1. >>> User.__table__   
2. Table('users', MetaData(None),  
3.     Column('id', Integer(), table=<users>, primary_key=True, nullable=False),  
4.     Column('name', String(), table=<users>),  
5.     Column('fullname', String(), table=<users>),  
6.     Column('password', String(), table=<users>), schema=None)  

当然找到描述表的数据结构，也应该能找到mapper，我们的Mapper对象可以通过 __mapper__ 属性来获取，比如这样的：

[python]  view plain  copy

1. >>> User.__mapper__   
2. <Mapper at 0x...; User>  

同样的MetaData可以通过.metadata属性找到。

好啦，下面轻松一下，见证奇迹的时刻，我们需不需要定义创建好实体数据库然后再定义ORM？对于SQLAlchemy来说这些都是小事一桩，其都可以给你一手包办，也就是说你可以完全不必理会数据库，交给SQLAlchemy就可以了，比如通过MetaData.create_all()并将engine参数传入即可（什么是engine？参考我的笔记1），比如通过下面的方式创建我们的users表。

[python]  view plain  copy

1. >>> Base.metadata.create_all(engine)   
2. PRAGMA table_info("users")  
3. ()  
4. CREATE TABLE users (  
5.     id INTEGER NOT NULL,  
6.     name VARCHAR,  
7.     fullname VARCHAR,  
8.     password VARCHAR,  
9.     PRIMARY KEY (id)  
10. )  
11. ()  
12. COMMIT  

由于我们开启了engine的echo=True，所以在交互命令下SQLAlchemy把SQL语句也输出了，正好可以检验是否符合我们的要求。

这样简单的create_all()我们就轻松建立起先前ORM映射定义的表啦。

时间不早了，今天先聊到这儿，下次再谈SQLAlchemy的其他特性。

sqlalchemy中文问题解决方案

http://firefish.blog.51cto.com/298258/112794/

[python]  view plain  copy

1. 'mysql://uid:pwd@localhost/mydb?charset=utf8'