Python3之sqlalchemy

SqlAlchemy是Python编程语言下的一款ORM框架，该框架建立在数据库API之上，使用关系对象映射进行数据库操作，简而言之：将对象转换成SQL，然后使用数据API执行SQL并获取执行结果。

ORM（对象关系映射）方法论基于三个核心原则：

  • 简单：以最基本的形式建模数据
  • 传达性：数据库结构被任何人都能理解的语言文档化
  • 精准性：基于数据模型创建正确标准化了的结构

Dialect用于和数据API进行交流，根据配置文件的不同调用的数据库API，从而实现对数据库的操作，如：

‘数据库类型+数据库驱动名称://用户名:口令@机器地址:端口号/数据库名‘


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

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...]

更多内容：http://docs.sqlalchemy.org/en/latest/dialects/index.html

备注：

    * Python2.7版本使用mysqldb

    * Python3.5版本使用pymysql

    * 使用pip或者源码包安装，确保环境可以正常使用。

    * 确保远程数据库服务器可以正常使用，并且拥有远程登陆权限

数据库授权：

    * mysql -uroot -p           # 登陆数据库

    * create database wang      # 创建数据库

    * grant all on wang.* to [email protected]"%" identified by ‘123‘ # 授权数据库

    * flush privileges          # 更新

　　

基本操作

（1）连接数据库：create_engine()

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

  • create_engine()   会返回一个数据库引擎
  • mysql+pymysql  “指定一个使用pymysql来连接”
  • 使用用户名‘root‘和密码‘123456‘来连接数据库‘wang‘
  • max_overflow 是最大连接数
  • charset : 设定连接时使用的字符集 charset = utf8
  • echo 参数如果为True时，会显示每条执行的SQL语句，生产环境下课关闭

（2）字段和数据类型及操作方法

在sqlalchemy.scherma包里有数据库关系的描述，列举几个常用的：

  • 字段 ： Column
  • 索引 ：Index
  • 表：Table

数据类型在sqlalchemy.types包，列举常用的：

  • 二进制：BIGINT
  • 布尔：BOOLEAN
  • 字符：CHAR
  • 可变字符：VARCHAR
  • 日期：DATATIME

（3）创建表结构

使用Schema Type/SQL Expression Language/Engine/ConnectionPooling/Dialect进行数据库操作。Engine使用Schema Type创建一个特定的结构对象，之后通过SQL Expression Language将该对象转换成SQL语句，然后通过ConnectionPooling连接数据库，再然后通过Dialect执行SQL，并获取结果。


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

#!/usr/bin/env python3

#coding:utf8

from sqlalchemy import create_engine, Table, Column, Integer, String, MetaData, ForeignKey

# 创建数据库连接

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

# 获取元数据

metadata = MetaData()

# 定义表

user = Table(‘user‘, metadata,

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

    Column(‘name‘, String(20)),

    )

color = Table(‘color‘, metadata,

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

    Column(‘name‘, String(20)),

    )

# 创建数据表，如果数据表存在，则忽视

metadata.create_all(engine)

　　

继承式增删改查

使用ORM/Schema Type/SQL Expression Language/Engine/ConnectionPooling/Dialect所有组件对数据库进行操作。根据类创建对象，对象转换成SQL，再执行SQL。

Query对象可以返回迭代的值（iterator value），然后我们可以通过for in 来查询。不过Query对象的all(), one()以及first()方法将返回非迭代值（non-iterator value），比如说all() 返回的是一个列表, first()方法限制并且仅作为标量返回结果集的第一条记录。

（1）创建数据库


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

#!/usr/bin/env python

# -*- coding:utf-8 -*-

from sqlalchemy.ext.declarative import declarative_base

from sqlalchemy import Column, Integer, String

from sqlalchemy.orm import sessionmaker

from sqlalchemy import create_engine

# 创建数据库

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

# 生成一个SqlORM 基类

Base = declarative_base()

# 定义表结构

class User(Base):

    # 表名

    __tablename__ = ‘users‘

    # 定义id,主键唯一,

    id = Column(Integer, primary_key=True)

    name = Column(String(50))

# 寻找Base的所有子类，按照子类的结构在数据库中生成对应的数据表信息

Base.metadata.create_all(engine)

# 创建与数据库的会话session class ,注意,这里返回给session的是个class,不是实例

Session = sessionmaker(bind=engine)

session = Session()

# 获取session，然后把对象添加到session

# 最后提交并关闭。Session对象可视为当前数据库连接。

　　（2）增加


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

#!/usr/bin/env python

# -*- coding:utf-8 -*-

from sqlalchemy.ext.declarative import declarative_base

from sqlalchemy import Column, Integer, String

from sqlalchemy.orm import sessionmaker

from sqlalchemy import create_engine

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

Base = declarative_base()

class User(Base):

    __tablename__ = ‘users‘

    id = Column(Integer, primary_key=True)

    name = Column(String(50))

Base.metadata.create_all(engine)

Session = sessionmaker(bind=engine)

session = Session()

####  添加 ########

# 定义一个字段

zengjia = User(id=2, name=‘sbliuyao‘)

# 添加字段

session.add(zengjia)

# 添加多个字段

session.add_all([

    User(id=3, name=‘sbyao‘),

    User(id=4, name=‘liuyao‘)

])

# 提交以上操作，现在只是在内存中增加，回写到数据库，就必须做提交操作

session.commit()

　　（3）删除


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

#!/usr/bin/env python

# -*- coding:utf-8 -*-

from sqlalchemy.ext.declarative import declarative_base

from sqlalchemy import Column, Integer, String

from sqlalchemy.orm import sessionmaker

from sqlalchemy import create_engine

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

Base = declarative_base()

class User(Base):

    __tablename__ = ‘users‘

    id = Column(Integer, primary_key=True)

    name = Column(String(50))

Base.metadata.create_all(engine)

Session = sessionmaker(bind=engine)

session = Session()

########### 删除 ##########

# 删除user表，id大于2的字段

session.query(User).filter(User.id > 2).delete()

session.commit()

　　（4）修改


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

#!/usr/bin/env python

# -*- coding:utf-8 -*-

from sqlalchemy.ext.declarative import declarative_base

from sqlalchemy import Column, Integer, String

from sqlalchemy.orm import sessionmaker

from sqlalchemy import create_engine

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

Base = declarative_base()

class User(Base):

    __tablename__ = ‘users‘

    id = Column(Integer, primary_key=True)

    name = Column(String(50))

Base.metadata.create_all(engine)

Session = sessionmaker(bind=engine)

session = Session()

# user表里的id等于2的字段修改为id=6

session.query(User).filter(User.id == 2).update({‘id‘ : 6})

session.commit()

　　（5）查询


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

42

43

44

45

46

47

###　查询方式1 ####

# 查询User表中字段是name=liuyao的第一条数据

ret = session.query(User).filter_by(name=‘liuyao‘).all()

print(ret)  # 输出ret，这是个对象的内存地址

for i in ret:

    print(i.id,i.name)  # 输出ret的内容

###　查询方式2 ####

# 查询user表里字段是name=liuyao的第一条数据

ret = session.query(User).filter_by(name=‘liuyao‘).first()

print(ret)        # 输出的结果为对象的内存地址

print(ret.name)   # 输出结果的name字段

print(ret.id)     # 输出结果的id字段

### 查询方式3 ###

# 查询user表里字段是name是liuyao或者mayun的信息打印出来

ret = session.query(User).filter(User.name.in_([‘liuyao‘,‘mayun‘])).all()

print(ret)

for i in ret:

    print(i.name,i.id)

### 查询方式4 ###

# 可以给返回的结果起一个别名，或者叫标签：可有可无

ret = session.query(User.name.label(‘‘)).all()

# 这里的关键是label方法，它的意思是把User的name字段改个名字叫name_label,

# 其相当于执行了：select users.name as name_label from User

print(ret,type(ret))

### 查询方式5 ###

# 查询User表根据id排序

ret = session.query(User).order_by(User.id).all()

print(ret)

for i in ret:

    print(i.name)

### 查询方式6 ###

# 查询user表里根据id排序输入0到3的字段

ret = session.query(User).order_by(User.id)[0:3]

print(ret)

for i in ret:

    print(i.name)

### 查询方式7 ###

# 创建Query查询，filter是where条件，最后调用one()返回唯一行，如果调用all()则返回所有行

user = session.query(User).filter(User.id==‘5‘).one()

print(type(user))  # 查看user的类型

print(user.name)   # 查看对象的name属性

　　（6）外键关联

由于关系型数据的多个表还可以用外键实现一对多，多对多等关联，相应的，ORM框架也可以提供两个对象之间的一对多，多对多等功能，

  • 一对多（一个User可以有多个Address）

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

42

43

44

45

46

47

48

49

50

51

52

53

54

#!/usr/bin/env python3

#coding:utf8

# 导入所需模块

from sqlalchemy import create_engine,func

from sqlalchemy.ext.declarative import declarative_base

from sqlalchemy import Column, Integer, String,ForeignKey

from  sqlalchemy.orm import sessionmaker,relationship

# 生成sqlorm基类

Base = declarative_base()

# 创建数据库连接

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

# 目的是一个人可以拥有多本书，那么在数据库里的一对多关系

class User(Base):

    # 表名

    __tablename__ = ‘user‘

    # id字段

    id = Column(String(20), primary_key=True)

    # 名字字段

    name = Column(String(20))

    # 一对多:

    # 内容不是表名而是定义的表结构名字

    books = relationship(‘Book‘)

class Book(Base):

    # 表明

    __tablename__ = ‘book‘

    # id字段

    id = Column(String(20), primary_key=True)

    # 名字字段

    name = Column(String(20))

    # “多”的一方的book表是通过外键关联到user表的:

    # ForeignKey是外键 关联user表的id字段

    user_id = Column(String(20), ForeignKey(‘user.id‘))

# 创建所需表

Base.metadata.create_all(engine)

if __name__ == ‘__main__‘:

    # 绑定,生成会话

    SessionCls = sessionmaker(bind=engine)

    session = SessionCls()

    # 创建用户

    liuyao = User(id=‘1‘,name=‘liuyao‘)

    ali = User(id=‘2‘,name=‘ali‘)

    # 添加字段

    session.add_all([liuyao,ali])

    # 提交

    session.commit()

    # 创建白鹿原这本书，指定谁是拥有者

    Whitedeer = Book(id=‘1‘,name=‘White_deer‘,user_id = ‘1‘)

    # 创建三体这本书，指定谁是拥有者

    Threebody = Book(id=‘2‘,name=‘Three_body‘,user_id = ‘2‘)

    # 添加字段

    session.add_all([Whitedeer,Threebody])

    # 提交

    session.commit()

　　

  • 多对多

建立一个双向一对多关系，“反向”是一个许多人，指定一个额外的relationship()函数，并连接两个使用relationship.back_populates参数。简单来说，relationship函数是sqlalchemy对关系之间提供的一种便利的调用方式，backref参数则对关系提供反向引用的声明。在最新版的sqlalchemy中对relationship引进了back_populates参数。


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

#!/usr/bin/env python3

#coding:utf8

from sqlalchemy import Column, Sequence, String, Integer, ForeignKey

from sqlalchemy import create_engine # 导入创建连接驱动

from sqlalchemy.ext.declarative import declarative_base

from sqlalchemy.orm import sessionmaker

from sqlalchemy.orm import relationship, backref

# 这个url可以用urlparse解析, 其中echo=True表示执行时显示sql语句

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

# 生成了declarative基类, 以后的model继承此类

Base = declarative_base()

class Parent(Base):

    __tablename__ = ‘parent‘

    id = Column(Integer, primary_key=True)

    name = Column(String(64),unique=True,nullable=False)

    children = relationship("Child", back_populates="parent")

class Child(Base):

    __tablename__ = ‘child‘

    id = Column(Integer, primary_key=True)

    name = Column(String(64),unique=True,nullable=False)

    parent_id = Column(Integer, ForeignKey(‘parent.id‘))

    parent = relationship("Parent", back_populates="children")

Base.metadata.create_all(engine) # 创建所有表结构

if __name__ == ‘__main__‘:

    SessionCls = sessionmaker(bind=engine)

    # 创建与数据库的会话session class ,注意,这里返回给session的是个class,不是实例

    session = SessionCls()

    mama = Parent(id=‘1‘,name=‘mamaxx‘)

    baba = Parent(id=‘2‘,name=‘babaoo‘)

    session.add_all([mama,baba])

    onesb = Child(id=‘1‘,name=‘onesb‘,parent_id=‘2‘)

    twosb = Child(id=‘2‘,name=‘twosb‘,parent_id=‘2‘)

    session.add_all([onesb,twosb])

    session.commit()
  • 多对多之三表外键关联

  • 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

    #!/usr/bin/env python3

    #coding:utf8

    from sqlalchemy import create_engine,func,Table

    from sqlalchemy.ext.declarative import declarative_base

    from sqlalchemy import Column, Integer, String,ForeignKey

    from sqlalchemy.orm import sessionmaker,relationship

    Base = declarative_base()

    # 关系表

    Host2Group = Table(‘host_2_group‘,Base.metadata,

                  Column(‘host_id‘,ForeignKey(‘hosts.id‘),primary_key=True),

                  Column(‘group_id‘,ForeignKey(‘group.id‘),primary_key=True),

                  )

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

    class Host(Base):

        __tablename__ = ‘hosts‘

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

        hostname = Column(String(64),unique=True,nullable=False)

        ip_addr = Column(String(128),unique=True,nullable=False)

        port = Column(Integer,default=22)

        groups = relationship(‘Group‘,

                          secondary= Host2Group,

                          backref = ‘host_list‘)

    class Group(Base):

        __tablename__ = ‘group‘

        id = Column(Integer,primary_key=True)

        name = Column(String(64),unique=True,nullable=False)

    Base.metadata.create_all(engine) # 创建所有表结构

    if __name__ == ‘__main__‘:

        SessionCls = sessionmaker(bind=engine)

        session = SessionCls()

        g1 = Group(name=‘g1‘)

        g2 = Group(name=‘g2‘)

        g3 = Group(name=‘g3‘)

        g4 = Group(name=‘g4‘)

        session.add_all([g1,g2,g3,g4])

        session.commit()

    　

原文地址：https://www.cnblogs.com/meng-wei-zhi/p/8259019.html

时间： 2024-10-11 11:44:13

Python3之sqlalchemy的相关文章

Python3：sqlalchemy对mysql数据库操作，非sql语句

Python3:sqlalchemy对mysql数据库操作,非sql语句 # python3 # author lizm # datetime 2018-02-01 10:00:00 # -*- coding: utf-8 -*- ''' 数据起始日期:2015-05-08 数据库:mysql ''' import requests from bs4 import BeautifulSoup import json import pymysql import datetime import ti

python3使用SQLAlchemy连接数据库

安装配置MariaDB yum install mariadb mariadb-server mariadb-devel create database first_sqlalchemy charset utf8; grant all privileges on first_sqlalchemy.* to 'heboan'@'%' identified by '123456'; flush privileges; 信息: 数据地址: 192.168.88.1:3306 数据库: first_sq

sqlalchemy 的 ORM 方式使用示例

知乎: 使用 sqlalchemy 的 orm 方式操作数据库是一种怎样的体验? 答: 爽! 本文基于:win10 + python3.4 + sqlAlchemy 1.0.13 下面展示其操作步骤: 1. 声明基类 from sqlalchemy.ext.declarative import declarative_base Base = declarative_base() 2. 定义表 from sqlalchemy import Column, Integer, ForeignKey f

Python 操作 MySQL 的正确姿势

欢迎大家关注腾讯云技术社区-博客园官方主页,我们将持续在博客园为大家推荐技术精品文章哦~ 作者:邵建永 使用Python进行MySQL的库主要有三个,Python-MySQL(更熟悉的名字可能是MySQLdb),PyMySQL和SQLAlchemy. Python-MySQL资格最老,核心由C语言打造,接口精炼,性能最棒,缺点是环境依赖较多,安装复杂,近两年已停止更新,只支持Python2,不支持Python3. PyMySQL为替代Python-MySQL而生,纯python打造,接口与Pyt

python3 下没办法运行sqlalchemy ？

[[email protected] python]# python3 router.py Traceback (most recent call last): File "/usr/local/lib/python3.6/site-packages/sqlalchemy/dialects/sqlite/pysqlite.py", line 337, in dbapi from sqlite3 import dbapi2 as sqlite  # try 2.5+ stdlib nam

Python3+SQLAlchemy+Sqlite3实现ORM教程

一.安装 Sqlite3是Python3标准库不需要另外安装,只需要安装SQLAlchemy即可.本文sqlalchemy版本为1.3.13 pip install sqlalchemy 二.ORM操作 除了第一步创建引擎时连接URL不一样,其他操作其他mysql等数据库和sqlite都是差不多的. 2.1 创建数据库连接格式说明 sqlite创建数据库连接就是创建数据库,而其他mysql等应该是需要数据库已存在才能创建数据库连接:建立数据库连接本文中有时会称为建立数据库引擎. 2.1.1 sq

python 学习笔记十一 SQLALchemy ORM(进阶篇)

SqlAlchemy ORM SQLAlchemy是Python编程语言下的一款ORM框架,该框架建立在数据库API之上,使用关系对象映射进行数据库操作,简言之便是:将对象转换成SQL,然后使用数据API执行SQL并获取执行结果. Dialect用于和数据API进行交流,根据配置文件的不同调用不同的数据库API,从而实现对数据库的操作,如: MySQL-Python mysql+mysqldb://<user>:<password>@<host>[:<port&g

Python3 之Web 框架：Django 基础

ango 优缺点 Django为人所称道的地方主要有: 完美的文档,Django的成功,我觉得很大一部分原因要归功于Django近乎完美的官方文档(包括Django book). 全套的解决方案,Django象Rails一样,提供全套的解决方案(full-stack framework + batteries included),基本要什么有什么(比如:cache.session.feed.orm.geo.auth),而且全部Django自己造,开发网站应手的工具Django基本都给你做好了,因

python操作mysql（pymysql + sqlalchemy）

pymysql pymsql是Python中操作MySQL的模块,其使用方法和MySQLdb几乎相同. 下载安装 pip3 install pymysql 使用操作 1.执行sql #!/usr/bin/env python # -*- coding:utf-8 -*- import pymysql # 创建连接 conn = pymysql.connect(host='127.0.0.1', port=3306, user='root', passwd='123', db='t1') # 创建