Python3之sqlalchemy

Posted 快乐糖果屋

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了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 wang@"%" identified by \'123\' # 授权数据库
    * flush privileges          # 更新

　　

基本操作

（1）连接数据库：create_engine()
 
engine = create_engine("mysql+pymysql://root:123456@127.0.0.1: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:123456@127.0.0.1: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:123456@127.0.0.1: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:123456@127.0.0.1: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:123456@127.0.0.1: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:123456@127.0.0.1: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:123456@127.0.0.1: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\')
  &

以上是关于Python3之sqlalchemy的主要内容，如果未能解决你的问题，请参考以下文章

在python3下怎样用flask-sqlalchemy对mysql数据库操作

python3 下没办法运行sqlalchemy ？

Python3-ORM-Sqlalchemy

Python3+SQLAlchemy+Sqlite3实现ORM教程

学习笔记：python3，代码片段（2017）

python3.7 sqlalchemy没有名为'MySQLdb'的模块[重复]

(c)2006-2024 SYSTEM All Rights Reserved IT常识