簡介

SQLAlchemy是Python語言的一款流行的ORM（Object Relational Mapper）框架，該框架建立在資料庫API之上，使用關系物件映射進行資料庫操作，即將物件轉換成SQL，然后使用資料API執行SQL并獲取執行結果，

安裝SQLAlchemy也很簡單，直接使用pip安裝即可，

pip install sqlalchemy

下面重點介紹SQLAlchemy的使用，

版本檢查

import sqlalchemy
sqlalchemy.__version__	# 1.1.9

當前sqlalchemy版本為1.1.9

連接資料庫

from sqlalchemy import create_engine
engine = create_engine('mysql+pymysql://root:[email protected]:3306/student', echo=True)

engine 是 Engine類的一個物件
echo=True表明開啟logging模塊的日志
資料庫連接：engine://user:password@host:port/database，其中engine為mysql+pymysql，或者是mysql+mysqldb，或者是oracle+cx_oracle等等

創建表

from sqlalchemy import create_engine
from sqlalchemy import Column, String, Integer
from sqlalchemy.ext.declarative import declarative_base


engine = create_engine('mysql+pymysql://root:[email protected]:3306/student', echo=True)
Base = declarative_base()  # 生成Model類的基類

class User1(Base):
    __tablename__ = 'user1'
    
    extend_existing = True
    # 定義三個列
    id = Column(Integer, autoincrement=True, primary_key=True)
    name = Column(String(64), unique=True, nullable=False)
    age  = Column(Integer)
    
        
    def __repr__(self):
        return 'User(id={}, name={}, age={})'.format(self.id, self,name, self.age)
    
    def __str__(self):
        return self.__repr__()
        
Base.metadata.create_all(engine)  # 創建所有表
Base.metadata.drop_all(engine)  # 洗掉所有表

# 定義類的實體方法1
u1 = User()	# User類只接收一個位置引數self，和關鍵字引數**kwargs
u1.name = 'aa'  # 給User類的各個列賦值
u1.age=19
print(u1)  # User(id=None, name=aa, age=19)

# 定義類的實體方法2
u2 = User(name='bb', age='123')
print(u2)  # User(id=None, name=bb, age=123)

派生類User會繼承基類Base的初始化函式__init__，會自動的接受我們所定義的列對應的關鍵字引數
未賦值的列會用None初始化，如上面的id

Session

SQLAlchemy真正處理資料庫的部分是Session，

如果已經創建好了一個Engine物件engine，那么可以用以下陳述句創建一個Session

from sqlalchemy.orm import sessionmaker
Session = sessionmaker(bind=engine)

如果engine為創建好，則可以用以下陳述句創建

Session = sessionmaker()

當engine創建好之后，在配置Session即可

Session.configure(bind=engine)

當需要和資料庫互動的時候，就需要實體化Session

session = Session()

創建完成之后這個session并沒有馬上獲取資料庫連接，只有當這個session第一次操作資料庫的時候才會從Engine維護的連接池中獲取一個連接，并持有這個連接一直到我們提交了所有的改變或者關閉了這個session，

DML

insert

user = User(name='haha', age='123')
session.add(user)
session.commit()

如果這個commit的程序中發生例外，則后續所有的commit都無法執行，因此DML都需要放在try...except中處理，如下

user = User(name='flowsnow', age=18)
session.add(user)
try:
    session.commit()
except Exception as e:
    session.rollback()
    raise e

update

和insert類似，都是使用session.add方法，但是update操作的時候需要資料庫中存在帶操作的記錄，

user.age = 20
session.add(user)
try:
    session.commit()
except Exception as e:
    session.rollback()
    raise e

delete

洗掉之前必須確保資料庫中存在要洗掉的記錄，

session.delete(user)	# user必須已經存在
try:
    session.commit()
except Exception as e:
    session.rollback()
    raise e

QUERY

for u in session.query(User).filter(User.age < 20).order_by(User.age.desc())[1:3]:
    print(u)

此條陳述句經ORM轉換之后的SQL如下：

SELECT
	USER.id AS user_id,
	USER.NAME AS user_name,
	USER.age AS user_age
FROM USER
WHERE USER.age < % (age_1) s
ORDER BY USER.age DESC
LIMIT % (param_1) s, % (param_2) s

query函式的回傳結果為一個Query物件，Query物件是可迭代的，支持切片操作，

下面列舉常見的filter操作

相等
```
query.filter(User.name == 'suncle')
```
不相等
```
query.filter(User.name != 'suncle')
```
模糊匹配like：大小寫敏感
```
query.filter(User.name.like('%sun%'))
```
模糊匹配ilike：大小寫不敏感
```
query.filter(User.name.ilike('%sun%'))
```

query.filter(User.name.in_(['suncle', 'abc', 'suncle']))

# 也支持Query物件
query.filter(User.name.in_(
    session.query(User.name).filter(User.name.like('%sun%'))
))

NOT IN

query.filter(~User.name.in_(['ed', 'wendy', 'jack']))

IS NULL

query.filter(User.name == None)

# 上面的寫法不符合pep8規范，IDE會給出提示，可以用下面的方法替代，pep8的寫法是is None
query.filter(User.name.is_(None))

IS NOT NULL

query.filter(User.name != None)

# 上面的寫法不符合pep8規范，IDE會給出提示，可以用下面的方法替代，pep8的寫法是is not None
query.filter(User.name.isnot(None))

AND

# 方法1：使用and_()方法
from sqlalchemy import and_
query.filter(and_(User.name == 'flowsnow', User.age == 18))

# 方法2：filter()支持多個關鍵字引數
query.filter(User.name == 'flowsnow', User.age == 18)

# 方法3：多次呼叫filter函式
query.filter(User.name == 'flowsnow').filter(User.age == 18)

from sqlalchemy import or_
query.filter(or_(User.name == 'suncle', User.name == 'flowsnow'))

下面列舉SQL支持的常見的function

from sqlalchemy import func
session.query(func.count(User.id)).first() # count
session.query(func.max(User.age)).first() # max
session.query(func.avg(User.age)).first() # avg

Relationship

表和表之間會有外鍵關系，資料庫的外鍵關系在ORM中的使用方法如下：

from sqlalchemy import create_engine
from sqlalchemy import Column, Integer, String
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker
from sqlalchemy import ForeignKey
from sqlalchemy.orm import relationship

Base = declarative_base()  # 生成Model類的基類

class Author(Base):  # 作者類
    __tablename__ = 'author'
    
    id = Column(Integer, primary_key=True, autoincrement=True)
    name = Column(String(64), unique=True, nullable=False)
    
    posts = relationship('Post')
    
    def __repr__(self):
        return 'Author<id={}， name={}>'.format(self.id, self.name)
    
    def __str__(self):
        return self.__repr__()
    
    
class Post(Base):  # 文章類
    __tablename__ = 'post'
    
    id = Column(Integer, primary_key=True, autoincrement=True)
    title = Column(String(128), nullable=False, index=True)
    content = Column(String(8096), nullable=False)
    author_id = Column(Integer, ForeignKey('author.id'), nullable=False)
    
    author = relationship('Author')
    
    def __repr__(self):
        return 'Post<id={}, title={}>'.format(self.id, self.title)
    
    def __str__(self):
        return self.__repr__()
    

engine = create_engine('mysql+pymysql://root:[email protected]:3306/student', echo=True)
Base.metadata.create_all(engine)
Session = sessionmaker(bind=engine)
session = Session()

# 新增一個作者
author = Author()
author.name = 'flowsnow'
session.add(author)
session.commit()
print(author)  # Author<id=1， name=flowsnow>

# 新增一篇文章
post = Post()
post.title = 'first post'
post.content = 'oihdoshfohro'
post.author = author
session.add(post)
session.commit()
print(author.posts)  # [Post<id=1, title=first post>]

# 再新增一篇文章
post = Post()
post.title = 'second post'
post.content = 'liabhgekegpaerg'
post.author = author
session.add(post)
session.commit()
print(author.posts)  # [Post<id=1, title=first post>, Post<id=2, title=second post>]

資料庫維護資料之間的外鍵關系會消耗資料庫資源，影響性能，在大型的應用中一般不使用外鍵等資料庫高級特性，而是由應用框架來維護資料之間的約束，

參考

官方檔案-Object Relational Tutorial
A step-by-step SQLAlchemy tutorial
廖雪峰-使用SQLAlchemy

記得幫我點贊哦！

精心整理了計算機各個方向的從入門、進階、實戰的視頻課程和電子書，按照目錄合理分類，總能找到你需要的學習資料，還在等什么？快去關注下載吧！！！

resource-introduce

念念不忘，必有回響，小伙伴們幫我點個贊吧，非常感謝，

我是職場亮哥，YY高級軟體工程師、四年作業經驗，拒絕咸魚爭當龍頭的斜杠程式員，

聽我說，進步多，程式人生一把梭

如果有幸能幫到你，請幫我點個【贊】，給個關注，如果能順帶評論給個鼓勵，將不勝感激，

職場亮哥文章串列：更多文章

wechat-platform-guide-attention

本人所有文章、回答都與著作權保護平臺有合作，著作權歸職場亮哥所有，未經授權，轉載必究！

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/163896.html

標籤：其他

上一篇：2、Spring Boot配置

下一篇：使用java代碼生成器出現的相關bug及處理

SQLAlchemy使用

簡介