sqlalchemy是什么,技术文档模板
终极管理员 知识笔记 82阅读
原文链接
sqlalchemy 官方文档
1.版本检查
import sqlalchemy
sqlalchemy.__version__
2.连接
from sqlalchemy import create_engine
engine create_engine(sqlite:///:memory:,echoTrue)
echo参数为True时会显示每条执行的SQL语句可以关闭。create_engine()返回一个Engine的实例并且它表示通过数据库语法处理细节的核心接口在这种情况下数据库语法将会被解释称Python的类方法。
3.声明映像
当使用ORM【1】时构造进程首先描述数据库的表然后定义我们用来映射那些表的类。在现版本的SQLAlchemy中这两个任务通常一起执行通过使用Declarative方法我们可以创建一些包含描述要被映射的实际数据库表的准则的映射类。
使用Declarative方法定义的映射类依据一个基类这个基类是维系类和数据表关系的目录——我们所说的Declarative base class。在一个普通的模块入口中应用通常只需要有一个base的实例。我们通过declarative_base()功能创建一个基类
from sqlalchemy.ext.declarativeimportdeclarative_base
Base declarative_base()
有了这个base我们可以依据这个base定义任意数量的映射类。一个简单的user例子
from sqlalchemy import Column, Integer, String
class User(Base):
__tablename__ users
id Column(Integer, primary_keyTrue)
name Column(String)
用Declarative构造的一个类至少需要一个__tablename__属性一个主键行。
4.构造模式项目中没用到
5.创建映射类的实例
ed_user User(nameed,fullnameEd Jones, passwordedspassword)
6.创建会话
现在我们已经准备毫和数据库开始会话了。ORM通过Session与数据库建立连接的。当应用第一次载入时我们定义一个Session类声明create_engine()的同时这个Session类为新的Session对象提供工厂服务。
from sqlalchemy.orm import sessionmaker
Session sessionmaker(bindengine)
这个定制的Session类会创建绑定到数据库的Session对象。如果需要和数据库建立连接只需要实例化一个Session
session Session()
虽然上面的Session已经和数据库引擎Engine关联但是还没有打开任何连接。当它第一次被使用时就会从Engine维护的一个连接池中检索是否存在连接如果存在便会保持连接知道我们提交所有更改并且/或者关闭session对象。
7.添加新对象简略
ed_user User(nameed, fullnameEd Jones, passwordedspassword)
session.add(ed_user)
至此我们可以认为新添加的这个对象实例仍在等待中ed_user对象现在并不代表数据库中的一行数据。直到使用flush进程Session才会让SQL保持连接。如果查询这条数据的话所有等待信息会被第一时间刷新查询结果也会立即发行。
session.commit()
通过commit()可以提交所有剩余的更改到数据库。
8.回滚
session.rollback()
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(nameed,fullnameEd Jones, passwordf8s7ccs)>ed
label()不知道怎么解释看下例子就明白了。相当于row.name
for row in session.query(User.name.label(name_label)).all():print(row.name_label)
aliased()我的理解是类的别名如果有多个实体都要查询一个类可以用aliased()
from sqlalchemy.orm import aliased
user_alias aliased(User, nameuser_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(�%)) #LIKE
uery.filter(User.name.in_([ed,wendy, jack])) #IN
query.filter(User.name.in_(session.query(User.name).filter(User.name.like(�%))#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(�)).order_by(User.id)
query.all()
[<User(nameed,fullnameEdJones, passwordf8s7ccs)>,<User(namefred,fullnameFredFlinstone, passwordblah)>]
first()适用于限制一个情况返回查询到的第一个结果作为标量好像只能作为属性类
query.first()<User(nameed,fullnameEd Jones, passwordf8s7ccs)>
one()完全获取所有行并且如果查询到的不只有一个对象或是有复合行就会抛出异常。
from sqlalchemy.orm.exc import MultipleResultsFound
user query.one()
try: user query.one()
except MultipleResultsFound, e:
print e
Multiple rows were found for one()
如果一行也没有
from sqlalchemy.orm.exc import NoResultFound
try: user query.filter(User.id 99).one()
exceptNoResultFound, 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()构造指定字符串的使用这种方法可以用在很多方法中像filter()和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(value224, namefred).order_by(User.id).one()
如果要用一个完整的SQL语句可以使用from_statement()。
ession.query(User).from_statement(text(SELECT* FROM users where name:name)).\
params(nameed).all()
也可以用from_statement()获取完整的”raw”用字符名确定希望被查询的特定列:
session.query(id,name, thenumber12).\from_statement(text(SELECT id, name, 12 as thenumber12 FROM users where name:name)).\
params(nameed).all()
[(1,ued, 12)]
感觉这个不太符合ORM的思想啊。。。
9.4 计数
count()用来统计查询结果的数量。
session.query(User).filter(User.name.like(�)).count()
func.count()方法比count()更高级一点【3】
from sqlalchemy import func
session.query(func.count(User.name),User.name).group_by(User.name).all()
[(1,ued), (1,ufred), (1,umary), (1,uwendy)]
为了实现简单计数SELECT count(*) FROM table可以这么写
session.query(func.count(*)).select_from(User).scalar()
如果我们明确表达计数是根据User表的主键的话可以省略select_from(User):
session.query(func.count(User.id)).scalar()
上面两行结果均为4。
Go to 下
10.建立联系外键
是时候考虑怎样映射和查询一个和Users表关联的第二张表了。假设我们系统的用户可以存储任意数量的email地址。我们需要定义一个新表Address与User相关联。
from sqlalchemyimport ForeignKeyfrom sqlalchemy.ormimport relationship, backref
class Address(Base):
__tablename__ addresses
id Column(Integer, primary_keyTrue)
email_address Column(String, nullableFalse)
user_id Column(Integer, ForeignKey(users.id))
user relationship(User, backrefbackref(addresses,order_byid))
def__repr__(self):
return<Address(email_address%s)>%self.email_address
构造类和外键简单就不过多赘述。主要说明以下relationship()函数这个函数告诉ORMAddress类应该和User类连接起来通过使用addresses.user。relationship()使用外键明确这两张表的关系。决定Adderess.user属性是多对一的。relationship()的子函数backref()提供表达反向关系的细节relationship()对象的集合被User.address引用。多对一的反向关系总是一对多。更多的细节参考Basic RelRational Patterns。
这两个互补关系Address.user和User.addresses被称为双向关系。这是SQLAlchemy ORM的一个非常关键的功能。更多关系backref的细节参见Linking Relationships with Backref。
假设声明的方法已经开始使用relationship()中和其他类关联的参数可以通过strings指定。在上文的User类中一旦所有映射成功为了产生实际的参数这些字符串会被当做Python的表达式。下面是一个在User类中创建双向联系的例子
class User(Base):
addresses relationship(Address, order_byAddress.id, backrefuser)
一些知识
在大多数的外键约束尽管不是所有的关系数据库只能链接到一个主键列或具有唯一约束的列。
外键约束如果是指向多个列的主键并且它本身也具有多列这种被称为“复合外键”。
外键列可以自动更新自己来相应它所引用的行或者列。这被称为级联是一种建立在关系数据库的功能。
外键可以参考自己的表格。这种被称为“自引”外键。
我们需要在数据库中创建一个addresses表所以我们会创建另一个元数据这将会跳过已经创建的表。
11.操作主外键关联的对象
现在我们已经在User类中创建了一个空的addresser集合可变集合类型例如set和dict都可以用但是默认的集合类型是list。
jack User(namejack, fullnameJack Bean, passwordgjffdd)
jack.addresses
[]
现在可以直接在User对象中添加Address对象。只需要指定一个完整的列表
jack.addresses [Address(email_addressjackgoogle.com),Address(email_addressj25yahoo.com)]
当使用双向关系时元素在一个类中被添加后便会自动在另一个类中添加。这种行为发生在Python的更改事件属性中而不是用SQL语句
>>> jack.addresses[1]
<Address(email_addressj25yahoo.com)>
>>> jack.addresses[1].user
<User(namejack, fullnameJack Bean, passwordgjffdd)>
把jack提交到数据库中再次查询JackNo SQL is yet issued for Jack’s addresses:这句实在是翻译不了了看看代码就明白是什么意思
>>> jack session.query(User).\...
filter_by(namejack).one()
>>> jack
<User(namejack,fullnameJack Bean, passwordgjffdd)>
>>>jack.addresses
[<Address(email_addressjackgoogle.com)>,<Address(email_addressj25yahoo.com)>]
当我们访问uaddresses集合时SQL会被突然执行这是一个延迟加载lazy loading关系的典型例子。现在addresses集合加载完成并且可以像对待普通列表一样对其进行操作。以后我们会优化这种加载方式。
12.使用JOINS查询
现在我们有了两张表可以进行更多的查询操作特别是怎样对两张表同时进行查询Wikipediapage on SQL JOIN提供了很详细的说明其中一些我们将在这里说明。之前用Query.filter()时我们已经用过JOIN了filter是一种简单的隐式join
>>>for u, a in session.query(User, Address).filter(User.idAddress.user_id).filter(Address.email_addressjackgoogle.com).all():
print u
print a
<User(namejack,fullnameJackBean, passwordgjffdd)>
<Address(email_addressjackgoogle.com)>
用Query.join()方法会更加简单
>>>session.query(User).join(Address).\
... filter(Address.email_addressjackgoogle.com).\
... all()
[<User(namejack,fullnameJackBean, passwordgjffdd)>]
之所以Query.join()知道怎么join两张表是因为它们之间只有一个外键。如果两张表中没有外键或者有一个以上的外键当下列几种形式使用的时候Query.join()可以表现的更好
query.join(Address,User.idAddress.user_id)# 明确的条件
query.join(User.addresses)# 指定从左到右的关系
query.join(Address,User.addresses) #同样有明确的目标
query.join(addresses) # 同样使用字符串
outerjoin()和join()用法相同
query.outerjoin(User.addresses)# LEFT OUTER JOIN
12.1使用别名
当在多个表中查询时如果同一张表需要被引用好几次SQL通常要求对这个表起一个别名因此SQL可以区分对这个表进行的其他操作。Query也支持别名的操作。下面我们joinAddress实体两次找到同时拥有两个不同email的用户
>>>from sqlalchemy.ormimport aliased
>>>adalias1 aliased(Address)
>>>adalias2 aliased(Address)
>>>for username, email1, email2 in\
... session.query(User.name,adalias1.email_address,adalias2.email_address).\
... join(adalias1, User.addresses).\
... join(adalias2, User.addresses).\
... filter(adalias1.email_addressjackgoogle.com).\
... filter(adalias2.email_addressj25yahoo.com):
... print username, email1,email2
jackjackgoogle.com j25yahoo.com
12.1使用子查询暂时理解不了啊多看代码研究吧(
from sqlalchemy.sqlimport func
stmt session.query(Address.user_id,func.count(*).\
... label(address_count)).\
... group_by(Address.user_id).subquery()
>>>for u, count in session.query(User,stmt.c.address_count).\
... outerjoin(stmt, User.idstmt.c.user_id).order_by(User.id):
print u, count
<User(nameed,fullnameEdJones, passwordf8s7ccs)>None
<User(namewendy,fullnameWendy Williams, passwordfoobar)>None
<User(namemary,fullnameMary Contrary, passwordxxg527)>None
<User(namefred,fullnameFred Flinstone, passwordblah)>None
<User(namejack,fullnameJack Bean, passwordgjffdd)>2
12.2从子查询中选择实体
上面的代码中我们只返回了包含子查询的一个列的结果。如果想要子查询映射到一个实体的话使用aliased()设置一个要映射类的子查询别名
>>>stmt session.query(Address).\
... filter(Address.email_address! j25yahoo.com).\
... subquery()
>>>adalias aliased(Address, stmt)#为什么有两个参数
>>>for user, address in session.query(User, adalias).\
... join(adalias, User.addresses):
... print user
... print address
<User(namejack,fullnameJack Bean, passwordgjffdd)>
<Address(email_addressjackgoogle.com)>
12.3使用EXISTS存在
如果表达式返回任何行EXISTS为真这是一个布尔值。它可以用在jions中也可以用来定位在一个关系表中没有相应行的情况
>>>from sqlalchemy.sqlimport exists
>>>stmt exists().where(Address.user_idUser.id)
>>>for name, in session.query(User.name).filter(stmt):
print name
jack
等价于
>>>for name, in session.query(User.name).\
... filter(User.addresses.any()):
... print name
jack
any()限制行匹配
>>>for name, in session.query(User.name).\
... filter(User.addresses.any(Address.email_address.like(%google%))):
... print name
jack
has()和any()一样在应对多对一关系的情况下注意““意味着”NOT”
>>> session.query(Address).\
... filter(~Address.user.has(User.namejack)).all()
[]
12.4 常见的关系运算符
None 都是用在多对一中而contains()用在一对多的集合中
query.filter(Address.user someuser)
query.filter(User.addresses.contains(someaddress))
Any()用于集合中
query.filter(User.addresses.any(Address.email_address bar))#also takes keyword arguments:
query.filter(User.addresses.any(email_addressbar))
as()用在标量不在集合中
query.filter(Address.user.has(nameed))
Query.with_parent()所有关系都适用
session.query(Address).with_parent(someuser,addresses)
13 预先加载跟性能有关和lazy loading相对建议直接查看文档吧
待补充。。。
SQLAlchemy技术文档中文版全