2. 程式人生 > >python ORM 框架 sqlalchemy

python ORM 框架 sqlalchemy

阿新 • • 發佈：2018-11-05

sqlalchemy 是一款Python語言寫的ORM框架， 該框架建立在資料庫API基礎之上。

 

sqlalchemy 本身無法操作資料庫，必須已第三方外掛為基礎，Dialect用於和資料API進行交流，根據不通的的配置呼叫不通的資料庫API,從而實現對資料庫的操作。

 

1

2

3

4

5

6

7

8

9

10

11

MySQL-Python

    mysql+mysqldb://<user>:<password>@<host>[:<port>]

/<dbname>

   

pymysql

    mysql+pymysql://<username>:<password>@<host>/<dbname>[?<options>]

   

MySQL-Connector

    mysql+mysqlconnector://<user>:<password>@<host>[:<port>]/<dbname>

   

cx_Oracle

    oracle+cx_oracle://user:pass@host:port/dbname[?key=value&key=value...]

 

ORM 

一、建立表

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

from

 sqlalchemy.ext.declarative import declarative_base

from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Index

from sqlalchemy.orm import sessionmaker, relationship

from sqlalchemy import create_engine

 

engine = create_engine("mysql+pymysql://root:[email protected]:3306/mybase", max_overflow=5)

 

BaseModel = declarative_base()

 

class Blog(BaseModel):

    __tablename__ = 'blog'

 

    id = Column(CHAR(32), primary_key=True)

    title = Column(String(64), server_default='', nullable=False)

    text = Column(String, server_default='', nullable=False)

    user = Column(CHAR(32), index=True, server_default='', nullable=False)

    create = Column(BIGINT, index=True, server_default='0', nullable=False)

 

 

class User(BaseModel):

    __tablename__ = 'user'

 

    id = Column(CHAR(32), primary_key=True)

    name = Column(String(32), server_default='', nullable=False)

    username = Column(String(32), index=True, server_default='', nullable=False)

    password = Column(String(64), server_default='', nullable=False)

 

 

def init_db():

    BaseModel.metadata.create_all(Engine) # 建立資料庫及表

 

def drop_db():

    BaseModel.metadata.drop_all(Engine) # 刪除資料庫及表

 

 

if __name__ == '__main__':

    #init_db()

    drop_db()

    #BaseModel.metadata.tables['user'].create(Engine, checkfirst=True)

    #BaseModel.metadata.tables['user'].drop(Engine, checkfirst=False)

    pass

　　

二、向資料庫新增資料

1

2

3

4

5

6

7

8

session = Session()

session.add(User(id=uuid.uuid4().hex))

session.add(Blog(id=uuid.uuid4().hex))

session.add_all([

    User(id=uuid.uuid4().hex),

    Blog(id=uuid.uuid4().hex)

])

session.commit()

 

三、查詢

查詢的結果, 有幾種不同的型別, 這個需要注意, 像是:

  • instance
  • instance of list
  • keyed tuple of list
  • value of list

1、普通查詢

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

session.query(User).filter_by(username='abc').all()

session.query(User).filter(User.username=='abc').all()

session.query(Blog).filter(Blog.create >= 0).all()

session.query(Blog).filter(Blog.create >= 0).first()

session.query(Blog).filter(Blog.create >= 0 | Blog.title == 'A').first()

session.query(Blog).filter(Blog.create >= 0 & Blog.title == 'A').first()

session.query(Blog).filter(Blog.create >= 0).offset(1).limit(1).scalar()

session.query(User).filter(User.username ==  'abc').scalar()

session.query(User.id).filter(User.username ==  'abc').scalar()

session.query(Blog.id).filter(Blog.create >= 0).all()

session.query(Blog.id).filter(Blog.create >= 0).all()[0].id

dict(session.query(Blog.id, Blog.title).filter(Blog.create >= 0).all())

session.query(Blog.id, Blog.title).filter(Blog.create >= 0).first().title

session.query(User.id).order_by('id desc').all()

session.query(User.id).order_by('id').first()

session.query(User.id).order_by(User.id).first()

session.query(User.id).order_by(-User.id).first()

session.query('id', 'username').select_from(User).all()

session.query(User).get('16e19a64d5874c308421e1a835b01c69')

　　

 2、多表查詢

1

2

3

4

5

session.query(Blog, User).filter(Blog.user == User.id).first().User.username

session.query(Blog, User.id, User.username).filter(Blog.user == User.id).first().id

session.query(Blog.id,

              User.id,

              User.username).filter(Blog.user == User.id).first().keys()

　　

3、條件查詢

1

2

3

4

5

6

7

8

9

from sqlalchemy import or_, not_

 

session.query(User).filter(or_(User.id == '',

                               User.id == '16e19a64d5874c308421e1a835b01c69')).all()

session.query(User).filter(not_(User.id == '16e19a64d5874c308421e1a835b01c69')).all()

session.query(User).filter(User.id.in_(['16e19a64d5874c308421e1a835b01c69'])).all()

session.query(User).filter(User.id.like('16e19a%')).all()

session.query(User).filter(User.id.startswith('16e19a')).all()

dir(User.id)

　　

4、函式

1

2

3

4

5

6

7

from sqlalchemy import func

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

session.query(func.count('1'), func.max(User.username)).select_from(User).first()

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

session.query(func.md5(User.username)).select_from(User).all()

session.query(func.current_timestamp()).scalar()

session.query(User).count()

 

四、修改

兩種修改方式

1

2

3

4

5

6

session.query(User).filter(User.username == 'abc').update({'name': '123'})

session.commit()

 

user = session.query(User).filter_by(username='abc').scalar()

user.name = '111'

session.commit()

 

如果涉及對屬性原值的引用, 則要考慮 synchronize_session 這個引數.

  • 'evaluate' 預設值, 會同時修改當前 session 中的物件屬性.
  • 'fetch' 修改前, 會先通過 select 查詢條目的值.
  • ‘False’ 不修改當前 session 中的物件屬性.

在預設情況下, 因為會有修改當前會話中的物件屬性, 所以如果語句中有 SQL 函式, 或者"原值引用", 那是無法完成的操作, 自然也會報錯, 比如:

1

2

3

from sqlalchemy import func

session.query(User).update({User.name: func.trim('123 ')}) # 使用了函式

session.query(User).update({User.name: User.name + 'x'}) #使用了原值引用<br><br># 以上兩種情況都會報錯

 

這種情況下, 就不能要求 SQLAlchemy 修改當前 session 的物件屬性了, 而是直接進行資料庫的互動, 不管當前會話值（將synchronize_session值設定為False）:

1

session.query(User).update({User.name: User.name + 'x'}, synchronize_session=False)

　　

是否修改當前會話的物件屬性, 涉及到當前會話的狀態. 如果當前會話過期, 那麼在獲取相關物件的屬性值時, SQLAlchemy 會自動作一次資料庫查詢, 以便獲取正確的值:

1

2

3

4

5

6

user = session.query(User).filter_by(username='abc').scalar()

print user.name

session.query(User).update({User.name: 'new'}, synchronize_session=fetch)

print user.name

session.commit()

print user.name

 

執行了 update 之後, 雖然相關物件的實際的屬性值已變更, 但是當前會話中的物件屬性值並沒有改變. 直到 session.commit() 之後, 當前會話變成"過期"狀態, 再次獲取 user.name 時, SQLAlchemy 通過 user 的 id 屬性, 重新去資料庫查詢了新值. 

synchronize_session 設定成 'fetch' 不會有這樣的問題, 因為在做 update 時已經修改了當前會話中的物件了.

不管 synchronize_session 的行為如何, commit 之後 session 都會過期, 再次獲取相關物件值時, 都會重新作一次查詢.

 

好好體會上邊的話。

 

五、刪除

刪除同樣有像修改一樣的 synchronize_session 引數的問題, 影響當前會話的狀態.

1

2

3

4

session.query(User).filter_by(username='abc').delete()

 

user = session.query(User).filter_by(username='abc').first()

session.delete(user)

 

六、join 操作

sqlalchemy 預設情況下的join 是內連線

1

2

3

r = session.query(Blog, User).join(User, Blog.user == User.id).all()

for blog, user in r:

    print blog.id, blog.user, user.id

　　

四、外來鍵和關係

1、外來鍵的定義

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

from sqlalchemy import Column, ForeignKey

from sqlalchemy.types import String, Integer, CHAR, BIGINT

 

class Blog(BaseModel):

    __tablename__ = 'blog'

 

    id = Column(BIGINT, primary_key=True, autoincrement=True)

    title = Column(String(64), server_default='', nullable=False)

    text = Column(String, server_default='', nullable=False)

    user = Column(BIGINT, ForeignKey('user.id'), index=True, nullable=False)

    create = Column(BIGINT, index=True, server_default='0', nullable=False)

        user_obj = relationship('User')

 

class User(BaseModel):

    __tablename__ = 'user'

 

    id = Column(BIGINT, primary_key=True, autoincrement=True)

    name = Column(String(32), server_default='', nullable=False)

    username = Column(String(32), index=True, server_default='', nullable=True)

    password = Column(String(64), server_default='', nullable=False)    blog_list = relationship('Blog', order_by='Blog.create')

 

新增資料

1

2

3

4

5

6

7

session = Session()

user = User(name='first', username=u'新的')

session.add(user)

session.flush()

blog = Blog(title=u'第一個', user=user.id)

session.add(blog)

session.commit()

 

session.flush() 是進行資料庫互動, 但是事務並沒有提交. 進行資料庫互動之後, user.id 才有值.

定義了外來鍵, 對查詢來說, 並沒有影響. 外來鍵只是單純的一條約束而已. 當然, 可以在外來鍵上定義一些關聯的事件操作, 比如當外來鍵條目被刪除時, 欄位置成 null , 或者關聯條目也被刪除等

 

獲取資料

1

2

3

session = Session()

print session.query(Blog).get(1).user_obj

print session.query(User).get(1).blog_list

對於 一對多 的關係, 使用 any() 函式查詢:

1

user = session.query(User).filter(User.blogs.any(Blog.title == u'A')).first()

反之, 如果是 多對一 的關係, 則使用 has() 函式查詢:

1

blog = session.query(Blog).filter(Blog.user_obj.has(User.name == u'XX')).first()

 

 

上面的關係定義, 對應的屬性是實際查詢出的例項列表, 當條目數多的時候, 這樣可能會有問題. 比如使用者名稱下有成千上萬的文章, 一次全取出就太暴力了. 關係對應的屬性可以定義成一個 Query 

1

2

3

4

5

6

7

class User(BaseModel):

    __tablename__ = 'user'

 

    id = Column(BIGINT, primary_key=True, autoincrement=True)

    name = Column(String(32), server_default='', nullable=False)

 

    blog_list = relationship('Blog', order_by='Blog.create', lazy="dynamic")

這樣就能自由控制了

1

2

session.query(User).get(1).blog_list.all()

session.query(User).get(1).blog_list.filter(Blog.title == 'abc').first()

　

2、關係的表現形式

關係在物件屬性中的表現, 預設是列表, 但是, 這不是唯一的形式. 根據需要, 可以作成 dictionary , set 或者其它你需要的物件.

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

class Blog(BaseModel):

    __tablename__ = 'blog'

 

    id = Column(Integer, autoincrement=True, primary_key=True)

    title = Column(Unicode(32), server_default='')

    user = Column(Integer, ForeignKey('user.id'), index=True)

 

    user_obj = relationship('User')

 

 

class User(BaseModel):

    __tablename__ = 'user'

 

    id = Column(Integer, autoincrement=True, primary_key=True)

    name = Column(Unicode(32), server_default='')

 

    blogs = relationship('Blog')

 

對於上面的兩個模型:

1

2

user = session.query(User).first()

print user.blogs

 

1

2

3

4

5

6

user = User(name=u'XX')

session.add_all([Blog(title=u'A', user_obj=user), Blog(title=u'B', user_obj=user)])

session.commit()

 

user = session.query(User).first()

print user.blogs

　　

現在 user.blogs 是一個列表. 我們可以在 relationship() 呼叫時通過 collection_class 引數指定一個類, 來重新定義關係的表現形式:

 

set, 集合

1

2

3

blogs = relationship('Blog', collection_class=set)

 

#InstrumentedSet([<__main__.Blog object at 0x1a58710>, <__main__.Blog object at 0x1a587d0>])

 

attribute_mapped_collection , 字典, 鍵值從屬性取:

1

2

3

4

5

from sqlalchemy.orm.collections import attribute_mapped_collection

 

blogs = relationship('Blog', collection_class=attribute_mapped_collection('title'))

 

#{u'A': <__main__.Blog object at 0x20ed810>, u'B': <__main__.Blog object at 0x20ed8d0>}

 

mapped_collection , 字典, 鍵值自定義:

1

2

3

4

5

from sqlalchemy.orm.collections import mapped_collection

 

blogs = relationship('Blog', collection_class=mapped_collection(lambda blog: blog.title.lower()))

 

#{u'a': <__main__.Blog object at 0x1de4890>, u'b': <__main__.Blog object at 0x1de4950>}

 

出處：https://www.cnblogs.com/9527chu/p/5713191.html

相關推薦

python ORM 框架 sqlalchemy

sqlalchemy 是一款Python語言寫的ORM框架， 該框架建立在資料庫API基礎之上。   sqlalchemy 本身無法操作資料庫，必須已第三方外掛為基礎，Dialect用於和資料API進行交流，根據不通的的配置呼叫不通的資料庫API,從而實現對資料庫的操作。

python(十二)下：ORM框架SQLAlchemy使用學習

func column bar 插入數據 ref min 統計 就是 連接 此出處：http://blog.csdn.net/fgf00/article/details/52949973 本節內容 ORM介紹 sqlalchemy安裝 sqlalchemy

SQLAlchemy 1.2.15 釋出，Python ORM 框架

   SQLAlchemy 1.2.15 釋出了，SQLAlchemy 是一個 Python 的 SQL 工具包以及資料庫物件關係對映框架。它包含整套企業級持久化模式，專門用於高效和高效能的資料庫訪問。 此版本包含了各種 ORM 級的修復，其中包括 1.2.13 中的

Python的ORM框架SQLAlchemy使用入門(一)

不要放棄你的幻想。當幻想沒有的時候，你還可以生存，但是你雖生猶死。 建立實體類，生成資料庫架構 import os import sys from sqlalchemy import Col

SQLAlchemy 1.2.16 釋出，Python ORM 框架

   SQLAlchemy 1.2.16 釋出了，SQLAlchemy 是一個 Python 的 SQL 工具包以及資料庫物件關係對映框架。它包含整套企業級持久化模式，專門用於高效和高效能的資料庫訪問。 此版本更新包含了一系列 dialect 和引擎級的修復，以及包含非 asc

Python ORM框架之 Peewee入門

lob shortcuts pymysql 主鍵 也會 roo username fault 有意思 　　之前在學Django時，發現它的模型層非常好用，把對數據庫的操作映射成對類、對象的操作，避免了我們直接寫在Web項目中SQL語句，當時想，如果這個模型層可以獨立出來使用

ORM框架SQLAlchemy與權限管理系統的數據庫設計

make nec elif target ora 第三方 增刪改 ont 好的 SQLAlchemy是Python編程語言下的一款ORM框架，該框架建立在數據庫API之上，使用對象關系映射進行數據庫操作，即：將對象轉換成SQL，然後使用數據API執行SQL並獲取執行結果。

ORM框架SQLAlchemy學習（未整理完）

性能 select create external 其他 class 學習 -m -- 一、基本介紹 　　以下介紹來自維基百科，自由的百科全書。 　　SQLAlchemy是Python編程語言下的一款開源軟件。提供了SQL工具包及對象關系映射（ORM）工具，使用MIT許

mysql八：ORM框架SQLAlchemy

mysql ORM框架SQLAlche一、介紹SQLAlchemy是Python編程語言下的一款ORM框架，該框架建立在數據庫API之上，使用關系對象映射進行數據庫操作，簡言之便是：將對象轉換成SQL，然後使用數據API執行SQL並獲取執行結果。1、安裝 pip3 install sqlalchemy

pyhton ORM框架SQLAlchemy基礎與建表

轉換成 .com 註意 mys mysql 規則 定義 django 都是 1、ORM框架：SQLALchemy 　　- 作用： 　　　　1.提供簡單的規則 　　　　2.自動轉換成SQL語句 　　- ORM框架的分類：從代碼和數據庫兩個角度來看的　　　 　　　　1、DB f

Python ORM框架Pony —— 什麼是Pony ORM？

Pony是一種高階的物件關係對映器。ORM允許開發人員以物件的形式處理資料庫的內容。關係資料庫包含儲存在表中的行。但是，當使用高階面嚮物件語言編寫程式時，可以以物件的形式訪問從資料庫檢索的資料，這樣十分方便。Pony ORM是一個Python語言庫，允許您方便地處理在關係資料庫中儲存為行的物件。

Python ORM框架Pony —— Pony入門

安裝 要安裝Pony我們首先要安裝好pip,假設我們已經安裝完成pip,請在dos命令視窗下鍵入以下命令： pip install pony 之後pip會自動將我們的Pony安裝到Python 2.7或Python 3上 要確保已成功安裝Pony，請以互動方式啟動Python編譯器並

ORM框架SQLAlchemy

一 介紹 SQLAlchemy是Python程式語言下的一款ORM框架，該框架建立在資料庫API之上，使用關係物件對映進行資料庫操作，簡言之便是：將物件轉換成SQL，然後使用資料API執行SQL並獲取執行結果。 1、安裝 pip3 install sqlalchemy 

第七篇：ORM框架SQLAlchemy

一 介紹 SQLAlchemy是Python程式語言下的一款ORM框架，該框架建立在資料庫API之上，使用關係物件對映進行資料庫操作，簡言之便是：將物件轉換成SQL，然後使用資料API執行SQL並獲取執行結果。 1、安裝 pip3 install sqlalchemy  2、架構與流程  

Python ORM框架簡介

ORM概念 ORM（Object Ralational Mapping，物件關係對映）用來把物件模型表示的物件對映到基於S Q L 的關係模型資料庫結構中去。這樣，我們在具體的操作實體物件的時候，就不需要再去和複雜的 SQ L 語句打交道，只需簡單的操作實體物件的屬性和方法

6、第八周 - 網絡編程進階 - Python語言下的SqlAlchemy ORM框架應用

() bind chan base pymysql commit 提交 輸出 echo Mysql SqlAlchemy 基本步驟 1、SqlAlchemy 基本結構語法如下： 案例： from sqlalchemy import create_engine,Colu

python對Mysql操作和使用ORM框架（SQLAlchemy）

普通多次查詢 user_id_list = session.query(HostToHostUser.host_user_id).join(Host).filter(Host.hostname=='c2').all() user_id_list = zip(*user_id_list) us

python ORM - sqlalchemy 操作使用

== from python filter OS char 一個 efault 連接數 python操作數據庫 使用 ORM - sqlalchemy,pymsql 安裝： pip install pymsq pip install sqlalchemy 一、 ‘‘‘

Python-Web框架之 - 利用SQLALchemy創建與數據庫MySQL的連接, 詳解用Flask時會遇到的一些大坑 !

mysqld 找到 兩個 數據庫增刪改查 紅色 -c 固定 web connector 經過這個小項目算是對Django與Flask這兩個web框架有了新的認識 , Django本身的輪子非常齊全 , 套路也很固定 , 新手在接觸Django框架時 , 不會陷入到處找輪子的

python——type()、metaclass元類和精簡ORM框架

定制 定義 attribute varchar elm cep 實例 編寫代碼 __main__ 1、type（）函數 #type()函數既可以返回一個對象的類型，又可以創建出新的類型， # 比如，我們可以通過type()函數創建出Hello類，而無需通過cl