sqlalchemy中文文檔 sqlalchemy中文手冊

psycopg22.7.3.2 官方最新版

• 類型：運動健身大�。�3.5M語言：中文 評分：5.0
• 標簽：

立即下載

SQLAlchemy 連接到關(guān)系型數(shù)據(jù)庫，關(guān)系型數(shù)據(jù)最擅長的東西就是關(guān)系。SQLAlchemy是Python編程語言下的一款開源軟件。提供了SQL工具包及對象關(guān)系映射（ORM）工具，使用MIT許可證發(fā)行。

1.版本檢查

import sqlalchemy

sqlalchemy.__version__

2.連接

from sqlalchemy import create_engine

engine = create_engine('sqlite:///:memory:',echo=True)

echo參數(shù)為True時，會顯示每條執(zhí)行的SQL語句，可以關(guān)閉。create_engine()返回一個Engine的實例，并且它表示通過數(shù)據(jù)庫語法處理細節(jié)的核心接口，在這種情況下，數(shù)據(jù)庫語法將會被解釋稱Python的類方法。

3.聲明映像

當使用ORM【1】時，構(gòu)造進程首先描述數(shù)據(jù)庫的表，然后定義我們用來映射那些表的類。在現(xiàn)版本的SQLAlchemy中，這兩個任務通常一起執(zhí)行，通過使用Declarative方法，我們可以創(chuàng)建一些包含描述要被映射的實際數(shù)據(jù)庫表的準則的映射類。

使用Declarative方法定義的映射類依據(jù)一個基類，這個基類是維系類和數(shù)據(jù)表關(guān)系的目錄——我們所說的Declarative base class。在一個普通的模塊入口中，應用通常只需要有一個base的實例。我們通過declarative_base()功能創(chuàng)建一個基類：

from sqlalchemy.ext.declarativeimportdeclarative_base

Base = declarative_base()

有了這個base，我們可以依據(jù)這個base定義任意數(shù)量的映射類。一個簡單的user例子：

from sqlalchemy import Column, Integer, String

class User(Base):

__tablename__= 'users'

id= Column(Integer, primary_key=True)

name = Column(String)

用Declarative構(gòu)造的一個類至少需要一個__tablename__屬性，一個主鍵行。

4.構(gòu)造模式（項目中沒用到）

5.創(chuàng)建映射類的實例

ed_user = User(name='ed',fullname='Ed Jones', password='edspassword')

6.創(chuàng)建會話

現(xiàn)在我們已經(jīng)準備毫和數(shù)據(jù)庫開始會話了。ORM通過Session與數(shù)據(jù)庫建立連接的。當應用第一次載入時，我們定義一個Session類（聲明create_engine()的同時），這個Session類為新的Session對象提供工廠服務。

from sqlalchemy.orm import sessionmaker

Session = sessionmaker(bind=engine)

這個定制的Session類會創(chuàng)建綁定到數(shù)據(jù)庫的Session對象。如果需要和數(shù)據(jù)庫建立連接，只需要實例化一個Session：

session = Session()

雖然上面的Session已經(jīng)和數(shù)據(jù)庫引擎Engine關(guān)聯(lián)，但是還沒有打開任何連接。當它第一次被使用時，就會從Engine維護的一個連接池中檢索是否存在連接，如果存在便會保持連接知道我們提交所有更改并且/或者關(guān)閉session對象。

7.添加新對象（簡略）

ed_user = User(name='ed', fullname='Ed Jones', password='edspassword')

session.add(ed_user)

至此，我們可以認為，新添加的這個對象實例仍在等待中；ed_user對象現(xiàn)在并不代表數(shù)據(jù)庫中的一行數(shù)據(jù)。直到使用flush進程，Session才會讓SQL保持連接。如果查詢這條數(shù)據(jù)的話，所有等待信息會被第一時間刷新，查詢結(jié)果也會立即發(fā)行。

session.commit()

通過commit()可以提交所有剩余的更改到數(shù)據(jù)庫。

8.回滾

session.rollback()

9.查詢

通過Session的query()方法創(chuàng)建一個查詢對象。這個函數(shù)的參數(shù)數(shù)量是可變的，參數(shù)可以是任何類或者是類的描述的集合。下面是一個迭代輸出User類的例子：

for instance in session.query(User).order_by(User.id):

print instance.name,instance.fullname

Query也支持ORM描述作為參數(shù)。任何時候，多個類的實體或者是基于列的實體表達都可以作為query()函數(shù)的參數(shù)，返回類型是元組：

name, fullname session.query(User.name,User.fullname): 

name, fullname

Query返回的元組被命名為KeyedTuple類的實例元組。并且可以把它當成一個普通的Python數(shù)據(jù)類操作。元組的名字就相當于屬性的屬性名，類的類名一樣。

 row session.query(User, User.name).all():

row.User,row.name

<User(name='ed',fullname='Ed Jones', password='f8s7ccs')>ed

label()不知道怎么解釋，看下例子就明白了。相當于row.name

row session.query(User.name.label('name_label')).all():

(row.name_label)

aliased()我的理解是類的別名，如果有多個實體都要查詢一個類，可以用aliased()

from sqlalchemy.orm import aliased

user_alias = aliased(User, name='user_alias')

row  session.query(user_alias,user_alias.name).all():

row.user_alias

Query的 基本操作包括LIMIT和OFFSET，使用Python數(shù)組切片和ORDERBY結(jié)合可以讓操作變得很方便。

u session.query(User).order_by(User.id)[1:3]:

#只查詢第二條和第三條數(shù)據(jù)

9.1使用關(guān)鍵字變量過濾查詢結(jié)果，filter 和 filter_by都適用�！�2】使用很簡單，下面列出幾個常用的操作：

query.filter(User.name == 'ed') #equals

query.filter(User.name != 'ed') #not equals

query.filter(User.name.like('%ed%')) #LIKE

uery.filter(User.name.in_(['ed','wendy', 'jack'])) #IN

query.filter(User.name.in_(session.query(User.name).filter(User.name.like('%ed%'))#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.返回列表和數(shù)量（標量？）

all()返回一個列表：可以進行Python列表的操作。

query = session.query(User).filter(User.name.like('%ed')).order_by(User.id)

query.all()

[<User(name='ed',fullname='EdJones', password='f8s7ccs')>,<User(name='fred', fullname='FredFlinstone', password='blah')>]

first()適用于限制一個情況，返回查詢到的第一個結(jié)果作為標量？：好像只能作為屬性，類

query.first()

<User(name='ed',fullname='Ed Jones', password='f8s7ccs')>

one()完全獲取所有行，并且如果查詢到的不只有一個對象或是有復合行，就會拋出異常。

from sqlalchemy.orm.exc import MultipleResultsFound

user = query.one()

:

　　user = query.one()

except 　　MultipleResultsFound, e:

　　print e

Multiple rows were found for one()

如果一行也沒有：

from sqlalchemy.orm.exc import NoResultFound

:

　　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”是不同的系統(tǒng)是極好的。（這句有語病�。├�如web服務返回，本來是在no results found情況下返回”404“的，結(jié)果在多個results found情況下也會跑出一個應用異常。

scalar()作為one()方法的依據(jù)，并且在one()成功基礎上返回行的第一列。

query = session.query(User.id).filter(User.name == 'ed')

query.scalar()

7

9.3.使用字符串SQL

字符串能使Query更加靈活，通過text()構(gòu)造指定字符串的使用，這種方法可以用在很多方法中，像filter()和order_by()。

from sqlalchemy import text

for user in session.query(User).filter(text("id<224")).order_by(text("id")).all()

綁定參數(shù)可以指定字符串，用params()方法指定數(shù)值。

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 計數(shù)

count()用來統(tǒng)計查詢結(jié)果的數(shù)量。

session.query(User).filter(User.name.like('%ed')).count()

func.count()方法比count()更高級一點【3】

from sqlalchemy import func

 session.query(func.count(User.name),User.name).group_by(User.name).all()

[(1,u'ed'), (1,u'fred'), (1,u'mary'), (1,u'wendy')]

為了實現(xiàn)簡單計數(shù)SELECT count(*) FROM table，可以這么寫：

session.query(func.count('*')).select_from(User).scalar()

如果我們明確表達計數(shù)是根據(jù)User表的主鍵的話，可以省略select_from(User):

session.query(func.count(User.id)).scalar()

上面兩行結(jié)果均為4。

10.建立聯(lián)系（外鍵）

是時候考慮怎樣映射和查詢一個和Users表關(guān)聯(lián)的第二張表了。假設我們系統(tǒng)的用戶可以存儲任意數(shù)量的email地址。我們需要定義一個新表Address與User相關(guān)聯(lián)。

ForeignKey

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')>"%self.email_address

構(gòu)造類和外鍵簡單，就不過多贅述。主要說明以下relationship()函數(shù)：這個函數(shù)告訴ORM，Address類應該和User類連接起來，通過使用addresses.user。relationship()使用外鍵明確這兩張表的關(guān)系。決定Adderess.user屬性是多對一的。relationship()的子函數(shù)backref()提供表達反向關(guān)系的細節(jié)：relationship()對象的集合被User.address引用。多對一的反向關(guān)系總是一對多。更多的細節(jié)參考Basic RelRational Patterns。

這兩個互補關(guān)系：Address.user和User.addresses被稱為雙向關(guān)系。這是SQLAlchemy ORM的一個非常關(guān)鍵的功能。更多關(guān)系backref的細節(jié)參見Linking Relationships with Backref。

假設聲明的方法已經(jīng)開始使用，relationship()中和其他類關(guān)聯(lián)的參數(shù)可以通過strings指定。在上文的User類中，一旦所有映射成功，為了產(chǎn)生實際的參數(shù)，這些字符串會被當做Python的表達式。下面是一個在User類中創(chuàng)建雙向聯(lián)系的例子：

class User(Base):

addresses = relationship("Address", order_by="Address.id", backref="user")

一些知識：

在大多數(shù)的外鍵約束（盡管不是所有的）關(guān)系數(shù)據(jù)庫只能鏈接到一個主鍵列，或具有唯一約束的列。

外鍵約束如果是指向多個列的主鍵，并且它本身也具有多列，這種被稱為“復合外鍵”。

外鍵列可以自動更新自己來相應它所引用的行或者列。這被稱為級聯(lián)，是一種建立在關(guān)系數(shù)據(jù)庫的功能。

外鍵可以參考自己的表格。這種被稱為“自引”外鍵。

我們需要在數(shù)據(jù)庫中創(chuàng)建一個addresses表，所以我們會創(chuàng)建另一個元數(shù)據(jù)，這將會跳過已經(jīng)創(chuàng)建的表。

11.操作主外鍵關(guān)聯(lián)的對象

現(xiàn)在我們已經(jīng)在User類中創(chuàng)建了一個空的addresser集合，可變集合類型，例如set和dict，都可以用，但是默認的集合類型是list。

jack = User(name='jack', fullname='Jack Bean', password='gjffdd')

jack.addresses

[]

現(xiàn)在可以直接在User對象中添加Address對象。只需要指定一個完整的列表：

jack.addresses = [Address(email_address='jack@google.com'),Address(email_address='j25@yahoo.com')]

當使用雙向關(guān)系時，元素在一個類中被添加后便會自動在另一個類中添加。這種行為發(fā)生在Python的更改事件屬性中而不是用SQL語句：

>>> jack.addresses[1]

<Address(email_address='j25@yahoo.com')>

>>> jack.addresses[1].user

<User(name='jack', fullname='Jack Bean', password='gjffdd')>

把jack提交到數(shù)據(jù)庫中，再次查詢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.com')>, <Address(email_address='j25@yahoo.com')>]

當我們訪問uaddresses集合時，SQL會被突然執(zhí)行，這是一個延遲加載（lazy loading）關(guān)系的典型例子�，F(xiàn)在addresses集合加載完成并且可以像對待普通列表一樣對其進行操作。以后我們會優(yōu)化這種加載方式。

12.使用JOINS查詢

現(xiàn)在我們有了兩張表，可以進行更多的查詢操作，特別是怎樣對兩張表同時進行查詢，Wikipediapage on SQL JOIN提供了很詳細的說明，其中一些我們將在這里說明。之前用Query.filter()時，我們已經(jīng)用過JOIN了，filter是一種簡單的隱式join：

>>>for u, a in session.query(User, Address).filter(User.id==Address.user_id).filter(Address.email_address=='jack@google.com').all():

    print u

    print a

<User(name='jack',fullname='JackBean', password='gjffdd')>

<Address(email_address='jack@google.com')>

用Query.join()方法會更加簡單：

>>>session.query(User).join(Address).\

...     filter(Address.email_address=='jack@google.com').\

...     all()

[<User(name='jack',fullname='JackBean', password='gjffdd')>]

之所以Query.join()知道怎么join兩張表是因為它們之間只有一個外鍵。如果兩張表中沒有外鍵或者有一個以上的外鍵，當下列幾種形式使用的時候，Query.join()可以表現(xiàn)的更好：

query.join(Address,User.id==Address.user_id)# 明確的條件

query.join(User.addresses)# 指定從左到右的關(guān)系

query.join(Address,User.addresses)    #同樣，有明確的目標

query.join('addresses') # 同樣，使用字符串

 outerjoin()和join()用法相同

query.outerjoin(User.addresses)# LEFT OUTER JOIN

12.1使用別名

當在多個表中查詢時，如果同一張表需要被引用好幾次，SQL通常要求對這個表起一個別名，因此，SQL可以區(qū)分對這個表進行的其他操作。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_address=='jack@google.com').\

...     filter(adalias2.email_address=='j25@yahoo.com'):

...     print username, email1, email2

jack jack@google.com j25@yahoo.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.id==stmt.c.user_id).order_by(User.id):

    print u, count

<User(name='ed',fullname='EdJones', password='f8s7ccs')> None

<User(name='wendy',fullname='Wendy Williams', password='foobar')> None

<User(name='mary',fullname='Mary Contrary', password='xxg527')> None

<User(name='fred',fullname='Fred Flinstone', password='blah')> None

<User(name='jack',fullname='Jack Bean', password='gjffdd')> 2

12.2從子查詢中選擇實體？

上面的代碼中我們只返回了包含子查詢的一個列的結(jié)果。如果想要子查詢映射到一個實體的話，使用aliased()設置一個要映射類的子查詢別名：

>>> stmt = session.query(Address).\

...      filter(Address.email_address!= 'j25@yahoo.com').\

...      subquery()

>>> adalias = aliased(Address, stmt) #？為什么有兩個參數(shù)？

>>> for user, address in session.query(User, adalias).\

...         join(adalias, User.addresses):

...     print user

...     print address

<User(name='jack',fullname='Jack Bean', password='gjffdd')>

<Address(email_address='jack@google.com')>

12.3使用EXISTS（存在？）

如果表達式返回任何行，EXISTS為真，這是一個布爾值。它可以用在jions中，也可以用來定位在一個關(guān)系表中沒有相應行的情況：

>>>from sqlalchemy.sqlimport exists

>>> stmt = exists().where(Address.user_id==User.id)

>>>name, 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()一樣在應對多對一關(guān)系的情況下（注意“～“意味著”NOT”）

>>> session.query(Address).\

...         filter(~Address.user.has(User.name=='jack')).all()

[]

12.4 常見的關(guān)系運算符

== ！= 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_address='bar'))

as()（用在標量？不在集合中）：

query.filter(Address.user.has(name='ed'))

Query.with_parent()（所有關(guān)系都適用）：

session.query(Address).with_parent(someuser,'addresses')

13 預先加載（跟性能有關(guān)）和lazy loading相對，建議直接查看文檔吧