python SQLAlchemy数据库工具

一、sqlalchemy概述与架构

1.SQLAlchemy

SQLAlchemy是Python编程语言下的一款开源软件。提供SQL包以及对象关联映射（ORM）工具，使用MIT许可证

SQLAlchemy采用简单的python语言，为高效和高性能的数据库访问设计，实现了完整的企业级持久模型

SQLAlchemy的理念是，SQL数据库的量级和性能重要于对象集合，而对象集合的抽象又重要于表和行

SQLAlchemy目标是提供兼容众多数据库，如SQLite，Mysql，SQLServer，Oracal

安装数据库模块 pip3 install sqlalchemy

2.SQLAlchemy架构图

SQLAlchemy分为ORM（对象管理映射工具）和Core（核心模块），还有DBAPI数据库接口

Core分为Engine核心，SQl语句支持，Connection Pooling连接池

3.ORM模型

ORM即对象关系映射

数据库是一个二维表，包含多行多列，把一个表的内容用Pthon的数据结构表示的话，可以有一个列表list表示,list每一个元素都是tuple，表示一行记录

[

('1','c')

('2','b')

('3','c')

]

用列表表示一行很难看出表的结构。如果把一个列表用一个类来表示，就很容易看出结构

class User(object):

def __init__(self,id,name)

self.id=id

self.name=name

u=User(1,'libai') #实例化对象

二、sqlalchemy连接数据库操作与定义映射关系类

1.连接mysql

通过create_engine实现数据库的链接

#!/usr/bin/env python3
from sqlalchemy import create_engine
# 创建连接到数据库的引擎
engine = create_engine(
#指定数据库、用户名、密码、连接到哪台服务器、库名等信息
'mysql+pymysql://用户名:密码@localhost/库名?charset=utf8',
encoding='utf8',
echo=True #终端输出
)

2.声明映射--ORM表映射基类

当时用ORM的时候，配置过程从描述数据库表开始

通过自定义类映射相应的表

通过声明系统实现类的映射，定义基类

from sqlalchemy.ext.declarative import declarative_base
Base=declarative_base()

3.创建映射类--数据库表结构

一旦创建了基类，就可以创建自定义映射类了，映射类相当于将表结构转换为类结构

from sqlalchemy import Column,Integer,String
class Departments(Base): # 必须继承于Base
__tablename__ = 'departments' # 库中的表名
dep_id = Column(Integer, primary_key=True) #Integer整数类型,primary_key主键
dep_name = Column(String(20), nullable=False, unique=True) #nullable非空约束，unique唯一性约束
def __str__(self):
return '[部门ID：%s, 部门名称：%s]' % (self.dep_id, self.dep_name)

4.创建架构--创建表

类构建完成后，表的信息将被写入到表的元数据（metadata），综上Departments类。可以看到表的结构信息

>>> Departments.__table__
Table('departments', MetaData(bind=None), Column('dep_id', Integer(), table=<departments>, primary_key=True, nullable=False), Column('dep_name', String(length=20), table=<departments>, nullable=False), schema=None)

>>> Base.metadata.create_add(engine) #在数据库中创建表

三、sqlalchemy的增删改查

1.创建会话类Session

ORM访问数据库的句柄被称为Session

>>>from sqlalchemy.orm import sessionmaker #导入模块
>>>Session=sessionmaker(bind=engine) #如果创建session时engine存在
>>>Session=sessionmaker() #创建session时engine不存在，可以后期绑定
>>>Session.configure(bin=engine)

2.Session添加新对象--数据库插入操作

会话类的实例对象用于绑定到数据库，当实例初次使用时，它将从Engine维护的连接池中获得一个连接，当所有的事务均被commit或会话对象关闭时，连接结束

>>>session=Session() #创建对话
>>>dep_dev=Departments(dep_name="财务部") #实例化对象
>>>session.add(dep_dev) #向session中插入一条字段
>>>session.commit() #提交
>>>session.close() #关闭会话
>>>ops = Departments(dep_id=2, dep_name='人事部') #一次提交多个字段
>>>dev = Departments(dep_id=3, dep_name='财务部')
>>>deps = [ops, dev]
>>>session = Session()
>>>session.add_all(deps)
>>>session.commit()
>>>session.close()

3.创建映射类--创建表结构--外键约束

ORM映射关系也可用于表间创建外键约束

class Employees(Base): # 必须继承于Base
__tablename__ = 'employees' # 库中的表名
# 每个属性都是表中的一个字段，是类属性
emp_id = Column(Integer, primary_key=True) #Integer整数类型,primary_key主键
name = Column(String(20), nullable=False) # String字符串类型，nullable非空约束
gender = Column(String(6))
phone = Column(String(11))
email = Column(String(50))
dep_id = Column(Integer, ForeignKey('departments.dep_id')) #与departments中dep_id做外键关联
def __str__(self):
return '员工：%s' % self.name

4.SQLAlchemy查询操作

通过session的query()函数创建查询对象

query()函数可以接受多种参数

1）查询所有字段

>>>session=Session()
>>>qresult=session.query(Departments).order_by(Departments.dep_id) #利用query函数查出记录存放到变量里
>>>for i in qresult:
>>> print(i)

2）查询部分字段

>>>session=Session()
>>>for id,name in session.query(Departments.id,Departments.name):
>>> print('id:%s , name: %s' % (id,name))

3)查询并排序

按照Departments.id排序显示

>>>session=Session()
>>>for id,name in session.query(Departments).order_by(Departments.id):
>>> print('id:%s , name: %s' % (id,name))

4)切片查询

切片查询一般与排序查询组合使用，常用于分页操作

>>>session=Session()
>>>for id,name in session.query(Departments).order_by(Departments.id)[2:10]:
>>> print('id:%s , name: %s' % (id,name))

5）条件查询（过滤查询）

过滤查询可以单独用也可以叠加使用,也可以使用or_ 或者and_

>>>session=Session()
>>>for id,name in session.query(Departments).filter(Departments.id==2):
>>> print('id:%s , name: %s' % (id,name))
#过滤查询可以单独用也可以叠加使用
>>>for id,name in session.query(Departments).filter(Departments.a>=100).filter(Departments.b>=100):
>>> print('id:%s , name: %s' % (id,name))
#也可以通过and_符号使用，代表即满足a又满足b
>>>for id,name in session.query(Departments).filter(and_(Departments.a>=100，(Departments.b>=100)):
>>> print('id:%s , name: %s' % (id,name))
#也可以通过or_符号使用，代表即满足a或b的任意一个
>>>for id,name in session.query(Departments).filter(or_(Departments.a>=100，(Departments.b>=100)):
>>> print('id:%s , name: %s' % (id,name))

常用过滤符：

相等：query.filter(Departments.name == ''libai")

不相等：query.filter(Departments.name != ''libai")

模糊查询：query.filter(Departments.name.like(''%li"))

in：query.filter(Departments.name.in_(['libai'，'zhangsan']) #查询libai或zhangsan

not in：query.filter(~Departments.name.in_(['libai'，'zhangsan']) #查询除libai或zhangsan

字段为空：query.filter(~Departments.name.is_(None) #查询为空的Departments.name字段字段不为空：query.filter(~Departments.name.isnot(None) #查询不为空的Departments.name字段

或查询：query(Departments).filter(and_(Departments.a>=100，(Departments.b>=100))

且查询：query(Departments).filter(or_(Departments.a>=100，(Departments.b>=100))

6）多表查询

通过join()方法实现多表查询

>>>session=Session()
>>>for id,name in session.query(Departments.name,Employees.name).join(Departments):
>>> print('id:%s , name: %s' % (id,name))

5.更新数据

通过session的update()方法更新

>>>session=Session()
>>>q1=session.query(Departments).filter(Departments.id==1) #通过变量保留查询结果
>>>q1=session.query(Departments).get(1) #如果主键是int类型可以直接获取
>>>q.update({Departments.name:'人事部'}) #更新值
#也可以一步到位
>>>session.query(Departments).filter(Departments.id==1).update({Departments.name:'人事部'})
>>>q.commit()
>>>q.close()

6.删除记录

通过session的delete()方法更新

>>>session=Session()
>>>q1=session.query(Departments).filter(Departments.id==1) #通过变量保留查询结果
>>>q1=session.query(Departments).get(1) #如果主键是int类型可以直接获取
>>>q.delete(q1) #更新值
>>>q.commit()
>>>q.close()

四、实验1--使用SQLAlchemy创建表

要求：

创建employees表
创建部门表
创建salary表
表间创建恰当的关系

步骤一：SQLAlchemy安装

注意：sqlalchemy可以连接各种数据库

[root@serwang ~]# pip3 install sqlalchemy

Collecting sqlalchemy

Downloading http://pypi.doubanio.com/packages/aa/cc/48eec885d81f7260b07d

961b3ececfc0aa82f7d4a8f45ff997e0d3f44ba/SQLAlchemy-1.2.11.tar.gz (5.6MB)

...

...

Installing collected packages: sqlalchemy

Running setup.py install for sqlalchemy ... done

Successfully installed sqlalchemy-1.2.11

You are using pip version 9.0.1, however version 18.0 is available.

You should consider upgrading via the 'pip install --upgrade pip' command.

步骤二：为SQLAlchemy创建数据库

MariaDB [tedu]> CREATE DATABASE tarena DEFAULT CHARSET 'utf8';

步骤三：创建部门表，创建dbconn.py文件，编写如下代码：

1) 创建连接到数据库的引擎

[root@localhost day10]# vim dbconn.py

#!/usr/bin/env python3

from sqlalchemy import create_engine

# 创建连接到数据库的引擎

engine = create_engine(

#指定数据库、用户名、密码、连接到哪台服务器、库名等信息

'mysql+pymysql://root:tedu.cn@localhost/tarena?charset=utf8',

encoding='utf8',

echo=True #终端输出

)

2)创建ORM映射，生成ORM映射所需的基类

from sqlalchemy.ext.declarative import declarative_base

Base = declarative_base()

3)自定义映射类，创建部门表

from sqlalchemy import Column, String, Integer

class Departments(Base): # 必须继承于Base

__tablename__ = 'departments' # 库中的表名

dep_id = Column(Integer, primary_key=True) #Integer整数类型,primary_key主键

dep_name = Column(String(20), nullable=False, unique=True) #nullable非空约束，unique唯一性约束

def __str__(self):

return '[部门ID：%s, 部门名称：%s]' % (self.dep_id, self.dep_name)

if __name__ == '__main__':

Base.metadata.create_all(engine) # 在数据库中创建表，如果库中已有同名的表，将不会创建

4)测试脚本执行，生成部门表

[root@localhost day10]# python3 dbconn.py #成功生成部门表

5)进入数据库查看结果

#登录数据库

[root@localhost day10]# mysql -uroot -ptedu.cn

#查看数据库表

MariaDB [(none)]> use tarena;

Reading table information for completion of table and column names

You can turn off this feature to get a quicker startup with -A

Database changed

MariaDB [tarena]> show tables;

+------------------+

| Tables_in_tarena |

+------------------+

| departments |

+------------------+

1 row in set (0.00 sec)

步骤四：创建员工表，在dbconn.py文件中添加如下数据：

1)创建员工表

from sqlalchemy import ForeignKey #导入外键

class Employees(Base): # 必须继承于Base

__tablename__ = 'employees' # 库中的表名

emp_id = Column(Integer, primary_key=True) #Integer整数类型,primary_key主键

name = Column(String(20), nullable=False) # String字符串类型，nullable非空约束

gender = Column(String(6))

phone = Column(String(11))

email = Column(String(50))

dep_id = Column(Integer, ForeignKey('departments.dep_id')) #与departments中dep_id做外键关联

def __str__(self):

return '员工：%s' % self.name

4)测试脚本执行，生成员工表

[root@localhost day10]# python3 dbconn.py #成功生成员工表

5)进入数据库查看结果

#登录数据库

[root@localhost day10]# mysql -uroot -ptedu.cn

#查看数据库表

MariaDB [(none)]> use tarena;

Reading table information for completion of table and column names

You can turn off this feature to get a quicker startup with -A

Database changed

MariaDB [tarena]> show tables;

+------------------+

| Tables_in_tarena |

+------------------+

| departments |

| employees |

+------------------+

2 rows in set (0.00 sec)

步骤五：创建工资表，在dbconn.py文件中添加如下数据：

1)创建工资表

from sqlalchemy import Date #导入外键

class Employees(Base): # 必须继承于Base

__tablename__ = 'employees' #库中的表名

emp_id = Column(Integer, primary_key=True) #Integer整数类型,primary_key主键

name = Column(String(20), nullable=False) # String字符串类型，nullable非空约束

gender = Column(String(6))

phone = Column(String(11))

email = Column(String(50))

dep_id = Column(Integer, ForeignKey('departments.dep_id')) #与departments中dep_id做外键关联

def __str__(self):

return '员工：%s' % self.name

class Salary(Base): # 必须继承于Base

__tablename__ = 'salary' # 库中的表名

auto_id = Column(Integer, primary_key=True) #Integer整数类型,primary_key主键

date = Column(Date) #导入日期

emp_id = Column(Integer, ForeignKey('employees.emp_id')) #与employees中emp_id做外键关联

basic = Column(Integer) #基本工资

awards = Column(Integer) #奖金

4)测试脚本执行，生成员工表

[root@localhost day10]# python3 dbconn.py #成功生成工资表

5)进入数据库查看结果

#登录数据库

[root@localhost day10]# mysql -uroot -ptedu.cn

#查看数据库表

MariaDB [(none)]> use tarena;

Reading table information for completion of table and column names

You can turn off this feature to get a quicker startup with -A

Database changed

MariaDB [tarena]> show tables;

+------------------+

| Tables_in_tarena |

+------------------+

| departments |

| employees |

| salary |

+------------------+

3 rows in set (0.00 sec)

五、实验2--使用SQLAlchemy做增删改查操作

要求：

分别在部门表、员工表和工资表中加入数据
通过SQLAlchemy代码实现
分别练习每次加入一行数据和每次可加入多行数据

步骤一：向部门表添加数据，创建add_department.py文件，添加如下代码：

1)创建映射类的实例

[root@localhost day10]# vim add_department.py

from dbconn import Departments

hr = Departments(dep_id=1, dep_name='hr')

print(hr.dep_name)

print(hr.dep_id)

测试执行结果：

[root@localhost day10]# python3 add_department.py

hr

1

登录数据库查看，部门表中数据为空，此时，并不会真正在数据库表中添加记录

MariaDB [tarena]> select * from departments;

Empty set (0.00 sec)

2) 想在数据库中添加数据需完成如下操作，创建会话类

在dbconn.py文件中，添加如下代码：

通过将sessionmaker与数据库引擎绑定，创建会话类Session

from sqlalchemy.orm import sessionmaker

Session = sessionmaker(bind=engine)

3)添加新对象

在add_department.py文件中添加如下代码：

from dbconn import Departments, Session

session = Session() #创建会话类实例

session.add(hr) #向实例绑定的数据库添加数据

session.commit() #将数据提交到实例对应数据库

session.close() #关闭session类

测试执行结果：

[root@localhost day10]# python3 add_department.py

登录数据库查看部门表中数据

MariaDB [tarena]> select * from departments;

+--------+----------+

| dep_id | dep_name |

+--------+----------+

| 1 | hr |

+--------+----------+

1 row in set (0.01 sec)

数据成功添加

4)批量添加新数据

在add_department.py文件中添加如下代码：

ops = Departments(dep_id=2, dep_name='operations')

dev = Departments(dep_id=3, dep_name='development')

finance = Departments(dep_id=4, dep_name='财务部')

deps = [ops, dev]

session = Session()

session.add_all(deps)

session.add(finance)

session.commit()

session.close()

此时注意：

添加过的数据不要再添加，即将session.add（hr）注释掉。

如果文件中有中文，注意在dbconn.py文件中，将engine的参数修改为如下代码：

engine=create_engine(

'mysql+pymysql://root:tedu.cn@localhost/tarena?charset=uU8',

encoding='uU8',

echo=True

)

测试执行结果：

[root@localhost day10]# python3 add_department.py

登录数据库查看部门表中数据

MariaDB [tarena]> select * from departments;

+--------+-------------+

| dep_id | dep_name |

+--------+-------------+

| 3 | development |

| 1 | hr |

| 2 | operations |

| 4 | 财务部 |

+--------+-------------+

4 rows in set (0.00 sec)

数据成功添加

步骤二：向员工表批量添加数据，创建add_employees.py文件，添加如下代码：

from dbconn import Employees, Session

wj = Employees(

emp_id=1,name='王俊',gender='男',phone='15678789090',email='wj@163.com', dep_id=3

)

wwc = Employees(

emp_id=2,name='吴伟超',gender='男',phone='13499887755',email='wwc@qq.com', dep_id=3

)

dzj = Employees(

emp_id=3, name='董枝俊', gender='男', phone='18900998877', email='dzj@163.com', dep_id=3

)

ltd = Employees(

emp_id=4, name='李通达', gender='男', phone='13378904567', email='ltd@163.com', dep_id=2)

wxy = Employees(

emp_id=5, name='王秀燕', gender='女', phone='15098765432', email='wxy@tedu.cn', dep_id=2)

gq = Employees(

emp_id=6, name='高琦', gender='女', phone='15876543212', email='gq@tarena.com', dep_id=1)

wzf = Employees(

emp_id=7, name='王召飞', gender='男', phone='15609871234', email='wzf@sohu.com', dep_id=1)

sy = Employees(

emp_id=8, name='孙燕', gender='女', phone='18567895435', email='sy@163.com', dep_id=4)

gpf = Employees(

emp_id=9, name='高鹏飞', gender='男', phone='13566889900', email='gpf@163.com', dep_id=2)

emps = [wj, wwc, dzj, ltd, wxy, gq, wzf, sy, gpf]

session = Session()

session.add_all(emps)

session.commit()

session.close()

测试执行结果：

[root@localhost day10]# python3 add_employees.py

登录数据库查看部门表中数据

MariaDB [tarena]> select * from employees;

+--------+-----------+--------+-------------+---------------+--------+

| emp_id | name | gender | phone | email | dep_id |

+--------+-----------+--------+-------------+---------------+--------+

| 1 | 王俊 | 男 | 15678789090 | wj@163.com | 3 |

| 2 | 吴伟超 | 男 | 13499887755 | wwc@qq.com | 3 |

| 3 | 董枝俊 | 男 | 18900998877 | dzj@163.com | 3 |

| 4 | 李通达 | 男 | 13378904567 | ltd@163.com | 2 |

| 5 | 王秀燕 | 女 | 15098765432 | wxy@tedu.cn | 2 |

| 6 | 高琦 | 女 | 15876543212 | gq@tarena.com | 1 |

| 7 | 王召飞 | 男 | 15609871234 | wzf@sohu.com | 1 |

| 8 | 孙燕 | 女 | 18567895435 | sy@163.com | 4 |

| 9 | 高鹏飞 | 男 | 13566889900 | gpf@163.com | 2 |

+--------+-----------+--------+-------------+---------------+--------+

9 rows in set (0.00 sec)

数据成功添加

步骤三：向工资表添加数据，创建add_ salary.py文件，添加如下代码：

from dbconn import Salary, Session

jan2018_1 = Salary(date='2018-01-10', emp_id=1, basic=10000, awards=2000)

jan2018_2 = Salary(date='2018-01-10', emp_id=2, basic=11000, awards=1500)

jan2018_3 = Salary(date='2018-01-10', emp_id=3, basic=11000, awards=2200)

jan2018_4 = Salary(date='2018-01-10', emp_id=4, basic=11000, awards=3000)

jan2018_5 = Salary(date='2018-01-10', emp_id=1, basic=13000, awards=2000)

jan2018_6 = Salary(date='2018-01-10', emp_id=6, basic=15000, awards=3000)

jan2018_7 = Salary(date='2018-01-10', emp_id=7, basic=9000, awards=3000)

jan2018_8 = Salary(date='2018-01-10', emp_id=8, basic=13000, awards=2000)

jan2018_9 = Salary(date='2018-01-10', emp_id=9, basic=13000, awards=1500)

session = Session()

sals = [jan2018_1, jan2018_2, jan2018_3,jan2018_4, jan2018_5, jan2018_6, jan2018_7, jan2018_8, jan2018_9]

session.add_all(sals)

session.commit()

session.close()

测试执行结果：

[root@localhost day10]# python3 add_ salary.py

登录数据库查看部门表中数据

MariaDB [tarena]> select * from salary;

+---------+------------+--------+-------+--------+

| auto_id | date | emp_id | basic | awards |

+---------+------------+--------+-------+--------+

| 1 | 2018-01-10 | 1 | 10000 | 2000 |

| 2 | 2018-01-10 | 2 | 11000 | 1500 |

| 3 | 2018-01-10 | 3 | 11000 | 2200 |

| 4 | 2018-01-10 | 4 | 11000 | 3000 |

| 5 | 2018-01-10 | 1 | 13000 | 2000 |

| 6 | 2018-01-10 | 6 | 15000 | 3000 |

| 7 | 2018-01-10 | 7 | 9000 | 3000 |

| 8 | 2018-01-10 | 8 | 13000 | 2000 |

| 9 | 2018-01-10 | 9 | 13000 | 1500 |

+---------+------------+--------+-------+--------+

9 rows in set (0.00 sec)

数据成功添加

步骤四：修改表中的记录，首先需要把记录找到

qset12 = session.query(Department).filter(Department.dep_name=='人事部')

hr = qset12.one()

步骤五：删除记录与修改类似，先找到记录再执行删除

qset13 = session.query(Employee).filter(Department.dep_name=='设计部')

dep = qset13.one()

session.delete(dep)

session.commit()

步骤六：查询每个员工所在的部门涉及的是多表查询，因为员工表中只有部门ID，部门名称在部门表中存储

qset10 = session.query(Employee.emp_name, Department.dep_name).join(Department)

for row in qset10:

print(row)