SQLAlchemy技术⽂档（中⽂版）（全）
1.版本检查
import sqlalchemy
sqlalchemy.__version__
2.连接
from sqlalchemy import create_engine
engine = create_engine('sqlite:///:memory:',echo=True)
echo参数为True时，会显⽰每条执⾏的SQL语句，可以关闭。create_engine()返回⼀个Engine的实例，并且它表⽰通过语法处理细节的核⼼接⼝，在这种情况下，数据库语法将会被解释称的类⽅法。
3.声明映像
当使⽤ORM【1】时，构造进程⾸先描述数据库的表，然后定义我们⽤来映射那些表的类。在现版本的SQLAlchemy中，这两个任务通常⼀起执⾏，通过使⽤Declarative⽅法，我们可以创建⼀些包含描述要
被映射的实际数据库表的准则的映射类。
使⽤Declarative⽅法定义的映射类依据⼀个基类，这个基类是维系类和数据表关系的⽬录——我们所说的Declarative base class。在⼀个普通的模块⼊⼝中，应⽤通常只需要有⼀个base的实例。我们通过declarative_base()功能创建⼀个基类：
declarative import declarative_base
Base = declarative_base()
有了这个base，我们可以依据这个base定义任意数量的映射类。⼀个简单的user例⼦：
from sqlalchemy import Column, Integer, String
class User(Base):
__tablename__='users'
id= Column(Integer, primary_key=True)
name = Column(String)
⽤Declarative构造的⼀个类⾄少需要⼀个__tablename__属性，⼀个主键⾏。
4.构造模式（项⽬中没⽤到）
5.创建映射类的实例
ed_user = User(name='ed',fullname='Ed Jones', password='edspassword')
6.创建会话
现在我们已经准备毫和数据库开始会话了。ORM通过Session与数据库建⽴连接的。当应⽤第⼀次载⼊时，我们定义⼀个Session类（声
明create_engine()的同时），这个Session类为新的Session对象提供⼯⼚服务。
import sessionmaker
Session = sessionmaker(bind=engine)
这个定制的Session类会创建绑定到数据库的Session对象。如果需要和数据库建⽴连接，只需要实例化⼀个Session：
session = Session()
虽然上⾯的Session已经和数据库引擎Engine关联，但是还没有打开任何连接。当它第⼀次被使⽤时，就会从Engine维护的⼀个连接池中检索是否存在连接，如果存在便会保持连接知道我们提交所有更改并且/或者关闭session对象。
7.添加新对象（简略）
ed_user = User(name='ed', fullname='Ed Jones', password='edspassword')
session.add(ed_user)
⾄此，我们可以认为，新添加的这个对象实例仍在等待中；ed_user对象现在并不代表数据库中的⼀⾏数据。直到使⽤flush进
程，Session才会让SQL保持连接。如果查询这条数据的话，所有等待信息会被第⼀时间刷新，查询结果也会⽴即发⾏。
sessionmit()
通过commit()可以提交所有剩余的更改到数据库。
8.回滚
9.查询
通过Session的query()⽅法创建⼀个查询对象。这个函数的参数数量是可变的，参数可以是任何类或者是类的描述的集合。下⾯是⼀个迭代输出User类的例⼦：
for instance in session.query(User).order_by(User.id):
print instance.name,instance.fullname
Query也⽀持ORM描述作为参数。任何时候，多个类的实体或者是基于列的实体表达都可以作为query()函数的参数，返回类型是元组：
for name, fullname in session.query(User.name,User.fullname):
print name, fullname
Query返回的元组被命名为KeyedTuple类的实例元组。并且可以把它当成⼀个普通的Python数据类操
作。元组的名字就相当于属性的属性名，类的类名⼀样。
for row in session.query(User, User.name).all():
print row.User,row.name
<User(name='ed',fullname='Ed Jones', password='f8s7ccs')>ed
label()不知道怎么解释，看下例⼦就明⽩了。相当于row.name
for row in session.query(User.name.label('name_label')).all():
print(row.name_label)
aliased()我的理解是类的别名，如果有多个实体都要查询⼀个类，可以⽤aliased()
import aliased
user_alias = aliased(User, name='user_alias')
for row in session.query(user_alias,user_alias.name).all():
print row.user_alias
Query的基本操作包括LIMIT和OFFSET，使⽤Python数组切⽚和ORDERBY结合可以让操作变得很⽅便。
for u in session.query(User).order_by(User.id)[1:3]:
#只查询第⼆条和第三条数据
9.1使⽤关键字变量过滤查询结果，filter 和filter_by都适⽤。【2】使⽤很简单，下⾯列出⼏个常⽤的操作：
query.filter(User.name =='ed') #equals
query.filter(User.name !='ed') #not equals
query.filter(User.name.like('%e d%')) #LIKE
uery.filter(User.name.in_(['ed','wendy', 'jack'])) #IN
query.filter(User.name.in_(session.query(User.name).filter(User.name.like('%e d%'))#IN
query.filter(~User.name.in_(['ed','wendy', 'jack']))#not IN
query.filter(User.name ==None)#is None
query.filter(User.name !=None)#not None
from sqlalchemy import and_
query.filter(and_(User.name =='ed',User.fullname =='Ed Jones')) # and
query.filter(User.name =='ed',User.fullname =='Ed Jones') # and
query.filter(User.name =='ed').filter(User.fullname =='Ed Jones')# and
from sqlalchemy import or_
query.filter(or_(User.name =='ed', User.name =='wendy')) #or
query.filter(User.name.match('wendy')) #match
9.2.返回列表和数量（标量？）
all()返回⼀个列表：可以进⾏Python列表的操作。
query = session.query(User).filter(User.name.like('%e d')).order_by(User.id)
query.all()
[<User(name='ed',fullname='EdJones', password='f8s7ccs')>,<User(name='fred',
fullname='FredFlinstone', password='blah')>]
first()适⽤于限制⼀个情况，返回查询到的第⼀个结果作为标量？：好像只能作为属性，类
query.first()
<User(name='ed',fullname='Ed Jones', password='f8s7ccs')>
one()完全获取所有⾏，并且如果查询到的不只有⼀个对象或是有复合⾏，就会抛出异常。
c import MultipleResultsFound
user = ()
try:
  user = ()
except
  MultipleResultsFound, e:
  print e
Multiple rows were found for one()
如果⼀⾏也没有：
c import NoResultFound
try:
  user = query.filter(User.id ==99).one()
except
NoResultFound, e:
  print e
No row was found for one()
one()⽅法对于想要解决“no items found”和“multiple items found”是不同的系统是极好的。（这句有语病啊）例如web服务返回，本来是在no results found情况下返回”404“的，结果在多个results found情况下也会跑出⼀个应⽤异常。
scalar()作为one()⽅法的依据，并且在one()成功基础上返回⾏的第⼀列。
query = session.query(User.id).filter(User.name =='ed')
query.scalar()
7
9.3.使⽤字符串SQL
字符串能使Query更加灵活，通过text()构造指定字符串的使⽤，这种⽅法可以⽤在很多⽅法中，像filte
r()和order_by()。
from sqlalchemy import text
for user in session.query(User).filter(text("id<224")).order_by(text("id")).all()
绑定参数可以指定字符串，⽤params()⽅法指定数值。
session.query(User).filter(text("id<:value and name=:name")).\
params(value=224, name='fred').order_by(User.id).one()
如果要⽤⼀个完整的SQL语句，可以使⽤from_statement()。
ession.query(User).from_statement(text("SELECT* FROM users where name=:name")).\
params(name='ed').all()
也可以⽤from_statement()获取完整的”raw”，⽤字符名确定希望被查询的特定列:
session.query("id","name", "thenumber12").\
from_statement(text("SELECT id, name, 12 as ""thenumber12 FROM users where name=:name")).\
　params(name='ed').all()
[(1,u'ed', 12)]
感觉这个不太符合ORM的思想啊。。。
9.4 计数
count()⽤来统计查询结果的数量。
session.query(User).filter(User.name.like('%e d')).count()
from sqlalchemy import func
session.unt(User.name),User.name).group_by(User.name).all()
[(1,u'ed'), (1,u'fred'), (1,u'mary'), (1,u'wendy')]
为了实现简单计数SELECT count(*) FROM table，可以这么写：
sql中select是什么意思session.unt('*')).select_from(User).scalar()
如果我们明确表达计数是根据User表的主键的话，可以省略select_from(User):
session.unt(User.id)).scalar()
上⾯两⾏结果均为4。
to （下）
10.建⽴联系（外键）
是时候考虑怎样映射和查询⼀个和Users表关联的第⼆张表了。假设我们系统的⽤户可以存储任意数量的email地址。我们需要定义⼀个新表Address与User相关联。
from sqlalchemy import ForeignKey
import relationship, backref
class Address(Base):
__tablename__ ='addresses'
id= Column(Integer, primary_key=True)
email_address = Column(String, nullable=False)
user_id = Column(Integer, ForeignKey('users.id'))
user = relationship("User", backref=backref('addresses',order_by=id))
def__repr__(self):
return"<Address(email_address='%s')>"%ail_address
构造类和外键简单，就不过多赘述。主要说明以下relationship()函数：这个函数告诉ORM，Address类应该和User类连接起来，通过使
⽤addresses.user。relationship()使⽤外键明确这两张表的关系。决定Adderess.user属性是多对⼀的。relationship()的⼦函数backref()提供表达反向关系的细节：relationship()对象的集合被User.address引⽤。多对⼀的反向关系总是⼀对多。更多的细节参考。
这两个互补关系：Address.user和User.addresses被称为双向关系。这是SQLAlchemy ORM的⼀个⾮常关键的功能。更多关系backref的细节参见。
假设声明的⽅法已经开始使⽤，relationship()中和其他类关联的参数可以通过strings指定。在上⽂的User类中，⼀旦所有映射成功，为了产⽣实际的参数，这些字符串会被当做的表达式。下⾯是⼀个在User类中创建双向联系的例⼦：
class User(Base):
addresses = relationship("Address", order_by="Address.id", backref="user")
⼀些知识：
在⼤多数的外键约束（尽管不是所有的）关系只能链接到⼀个主键列，或具有唯⼀约束的列。
外键约束如果是指向多个列的主键，并且它本⾝也具有多列，这种被称为“复合外键”。
外键列可以⾃动更新⾃⼰来相应它所引⽤的⾏或者列。这被称为级联，是⼀种建⽴在关系数据库的功能。
外键可以参考⾃⼰的表格。这种被称为“⾃引”外键。
我们需要在数据库中创建⼀个addresses表，所以我们会创建另⼀个元数据，这将会跳过已经创建的表。
11.操作主外键关联的对象
现在我们已经在User类中创建了⼀个空的addresser集合，可变集合类型，例如set和dict，都可以⽤，但是默认的集合类型是list。
jack = User(name='jack', fullname='Jack Bean', password='gjffdd')
jack.addresses
[]
现在可以直接在User对象中添加Address对象。只需要指定⼀个完整的列表：
jack.addresses = [Address(email_address='jack@google'),Address(email_address='j25@yahoo')]
当使⽤双向关系时，元素在⼀个类中被添加后便会⾃动在另⼀个类中添加。这种⾏为发⽣在Python的更改事件属性中⽽不是⽤SQL语句：
>>> jack.addresses[1]
<Address(email_address='j25@yahoo')>
>>> jack.addresses[1].user
<User(name='jack', fullname='Jack Bean', password='gjffdd')>
把jack提交到数据库中，再次查询Jack，（No SQL is yet issued for Jack’s addresses:）这句实在是翻译不了了，看看代码就明⽩是什么意思：
>>> jack = session.query(User).\
...
filter_by(name='jack').one()
>>> jack
<User(name='jack',fullname='Jack Bean', password='gjffdd')>
>>>jack.addresses
[<Address(email_address='jack@google')>,
<Address(email_address='j25@yahoo')>]
当我们访问uaddresses集合时，SQL会被突然执⾏，这是⼀个延迟加载（）关系的典型例⼦。现在addresses集合加载完成并且可以像对待普通列表⼀样对其进⾏操作。以后我们会优化这种加载⽅式。
12.使⽤JOINS查询
现在我们有了两张表，可以进⾏更多的查询操作，特别是怎样对两张表同时进⾏查询，提供了很详细的说明，其中⼀些我们将在这⾥说明。之前
⽤Query.filter()时，我们已经⽤过JOIN了，filter是⼀种简单的隐式join：
>>>for u, a in session.query(User, Address).filter(User.id==Address.user_id).ail_address=='jack@google').all():
print u
print a
<User(name='jack',fullname='JackBean', password='gjffdd')>
<Address(email_address='jack@google')>
⽤Query.join()⽅法会更加简单：
>>>session.query(User).join(Address).\
...
ail_address=='jack@google').\

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。