mysql基础（六）之sqlAchemy
内容导读
互联网集市收集整理的这篇技术教程文章主要介绍了mysql基础（六）之sqlAchemy，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含9832字，纯文字阅读大概需要15分钟。
内容图文
参考博客：http://www.cnblogs.com/wupeiqi/articles/5713330.html
函数编程：数据和逻辑分离
a= 123
b = 456
c = 789
def exc3(proc_name):
callproc(xxx)
return xxx
def exc4(proc_name):
callproc(xxx)
return xxx
面向对象产生的原因:
1 当一类函数共用同样的参数的时候，可以转变成类进行 --分类
面向对象：数据和逻辑（属性和行为）组合在一起
class SqlHelper:
def __init__(self):
self.host = ‘‘
self.port =‘‘
self.db =‘‘
self.charset=‘‘
def exc1(self,SQL):
# 连接
conn(self.host,)
execute("inser")
return xx
def exc2(self,proc_name):
callproc(xxx)
return xxx
2 模板‘约束’ ： 一类事物共同具有： 属性和行为
class Person:
def __init__(self,name):
self.name=name
def speak(self):
pass
数据库中的面向对象：
每一张表作为一个类 对象：行
class Userinfo:
def __init__(self,id,name):
self.id = id
self.name= name
def add(self,name):
pass
...
# row1 = UserInfo(1,‘alex‘) # 第一行
# row2 = UserInfo(2,‘alex‘) # 第二行
面向对象中的特殊方法：
class Foo:
def __init__(self,name):
self.name=name
def __call__(self):
pass
def __getitem__(self,key):
pass
def __setitem__(self,key,value):
pass
def __delitem__(self,key):
pass
obj = Foo(‘alex‘)
obj()
obj[‘k‘]
obj[‘k‘]=124
del obj[‘k‘]
obj.__dict__
对象-关系映射（OBJECT/RELATIONALMAPPING，简称ORM），是随着面向对象的软件开发方法发展而产生的。用来把对象模型表示的对象映
射到基于S Q L 的关系模型数据库结构中去。这样，我们在具体的操作实体对象的时候，就不需要再去和复杂的 SQ L 语句打交道，只需
简单的操作实体对象的属性和方法[2] 。O R M 技术是在对象和关系之间提供了一条桥梁，前台的对象型数据和数据库中的关系型的数
据通过这个桥梁来相互转化
ORM框架：
作用：提供简单的规则
自动转换成sql语句
2种模型： DBfirst 手动创建数据库和表 ----》ORM框架----》自动生成类
codefirst 手动创建类和数据库 ------》ORM框架------》生成表
功能：
-- 创建数据库表
连接数据库（非sqlalchemy链接,而是由pymysql,mysqldb，，，等第三方插件进行链接）
类转换sql语句（sqlalchemy/engine/dialect）
-- 操作数据行
增删改查
1
from sqlalchemy.ext.declarative import declarative_base
2
from sqlalchemy import Column,Integer,String,ForeignKey,UniqueConstraint,Index,VARCHAR
3
from sqlalchemy.orm import sessionmaker,relationship
4
from sqlalchemy import create_engine
5
# 创建对象的基类
6 Base=declarative_base()
7 8 """
91 白金
102 黑金
11obj.xx ==> [obj,obj...]
12 """
13class UserType(Base):
14 __tablename__=‘usertype‘
15 id = Column(Integer,primary_key=True,autoincrement=True)
16 title=Column(VARCHAR(32),nullable=True,index=True)
17 18 """
191 方少伟 1
202 成套 1
213 小白 2
22ut = relationship（backref=‘xx‘）
23obj.ut ==> 1 白金
24 """
25class Users(Base):
26 __tablename__=‘users‘
27 id=Column(Integer,primary_key=True,autoincrement=True)
28 name=Column(String(32),nullable=True,index=True)
29 email=Column(String(16),unique=True)
30 user_type_id = Column(Integer,ForeignKey(‘usertype.id‘))
31 32 # 与生成表结构无关，仅用于查询方便
33 user_type=relationship(‘UserType‘,backref=‘xxoo‘)
34 35 __table_args__ = (
36 UniqueConstraint(‘id‘,‘name‘,name=‘uni_id_name‘),
37 Index(‘ix_n_ma‘,‘name‘,‘email‘)
38 )
39#创建引擎 引擎调用dialect来选择相应的模块来操作数据库
40 engine=create_engine(‘mysql+pymysql://root:123@127.0.0.1:3306/db1?charset=utf8‘,max_overflow=5)
41Base.metadata.create_all(engine) # 创建模块中所有继承base的class的表
42 43 Session= sessionmaker(bind=engine) # 从连接池中取得一个连接
44 session=Session() # 实例化出来一个会话连接，session用于创建程序和数据库之间的会话，所有对象的载入和保存都需要通过session对象
45###########增加########
46 obj1=UserType(title=‘普通‘)
47session.add(obj1)
48 49 objs=[
50 UserType(title=‘超级‘),
51 UserType(title=‘白金‘),
52 UserType(title=‘黑金‘),
53]
54session.add_all(objs)
55session.commit()
56 57###########查找########
58print(session.query(UserType))
59 user_type_list = session.query(UserType).all()
60 print(type(user_type_list[0])) # 对象
61for row in user_type_list:
62 print(row.id,row.title)
63 64#############删除###########
65 session.query(UserType.id,UserType.title).filter(UserType.id>2).delete()
66session.commit()
67#############修改#############
68 session.query(UserType.id,UserType.title).filter(UserType.id > 0).update({‘title‘:‘黑金‘})
69 session.query(UserType.id,UserType.title).filter(UserType.id> 0).update({UserType.title:UserType.title+"x"},synchronize_session=False)
70 session.query(UserType.id,UserType.title).filter(UserType.id>0).update({‘num‘:Users.num+1},synchronize_session=‘evaluate‘)
71session.commit()
72 73# 分组，排序，连表，通配符，子查询，limit,union,where,原生sql
74 75 76# 条件
77 ret = session.query(Users).filter_by(name=‘alex‘).all() # filter_by 里面放参数
78 ret = session.query(Users).filter(Users.id <9,Users.name==‘alex‘).all() #默认为and的关系 filter 里面放表达式
79# 不加.all() 返回迭代器对象 加.all() 返回所有的对象,放在一个列表里
80 print(ret[0].name)
81 ret = session.query(Users).filter(Users.id.between(1,3),Users.name==‘alex‘)
82for row in ret:
83 print(row.name)
84 ret = session.query(Users).filter(Users.id.in_([1,3,4])).all()
85 ret = session.query(Users).filter(~Users.id.in_([1,3,4])).all() #表示非的意思
86 87from sqlalchemy import and_,or_
88 ret = session.query(Users).filter(and_(Users.id <9,Users.name==‘alex‘))
89 90 ret = session.query(Users).filter(
91 or_(
92 Users.id<2,
93 and_(Users.name == ‘eric‘, Users.id > 3),
94 Users.email != ‘‘
95 )
96)
97 98 99# 通配符
100 ret = session.query(Users).filter(~Users.name.like(‘e%‘))
101#限制
102 ret = session.query(Users)[1:2]
103# 排序
104 ret = session.query(Users).order_by(Users.name.desc())
105 ret = session.query(Users).order_by(Users.name.desc(),Users.id.asc())
106#
107# #分组
108from sqlalchemy import func
109 ret = session.query(Users).group_by(Users.email).all()
110111 ret = session.query(
112 func.max(Users.id),
113 func.min(Users.id),
114 func.sum(Users.id),
115 ).group_by(Users.name).having(func.min(Users.id)>2).all()
116117118119#连表的两种方式:
120 ret=session.query(Users,UserType) #系统自动补全Users.user_type_id==UserType.id
121 ret1=session.query(Users,UserType).filter(Users.user_type_id==UserType.id)
122123 result=session.query(Users).join(UserType)
124 result1=session.query(Users).join(UserType,isouter=True) #相当于left join
125print(result1)
126127128###########临时表的用法###########
129 1
130 ret1=session.query(Users,UserType).filter(Users.user_type_id==UserType.id)
131for row in ret1:
132 print(row.Users.id,row.UserType.title)
133 2
134 q1=session.query(UserType).filter(UserType.id>0).subquery()
135 result=session.query(q1).all()
136print(result)
137 3
138 result=session.query(UserType.id,session.query(Users.id).as_scalar())
139print(result)
140for row in result:
141 print(row[0])
142143144 result1=session.query(UserType.id,session.query(Users).filter(Users.user_type_id==UserType.id).as_scalar())
145print(result1)
146147#组合
148149 q1 = session.query(Users.name).filter(Users.id <3)
150 q2= session.query(UserType.title).filter(UserType.id <3)
151 ret = q1.union(q2).all()
152print(ret)
153154 q1 = session.query(Users.name).filter(Users.id <3)
155 q2= session.query(UserType.title).filter(UserType.id <3)
156 ret = q1.union_all(q2).all()
157print(ret)
158159160 #########################relationship***************************
161 # 问题：获取用户信息以及与其关联的用户类型名称（fk,relationship ==> 正向操作）
162 user_list1=session.query(Users,UserType).join(UserType,isouter=True)
163print(user_list1)
164for row in user_list1:
165 print(row[0].id,row[0].name,row[0].email,row[0].user_type_id,row[1].title)
166167 user_list2=session.query(Users.name,UserType.title).join(UserType,isouter=True).all()
168print(user_list2)
169for row in user_list2:
170 print(row.name,row.title)
171172 user_list=session.query(Users)
173for row in user_list:
174 print(row.id,row.name,row.user_type.title)
175176177# 问题二：获取用户类型下的用户名 反向操作
178 type_list1=session.query(UserType)
179for row in type_list1:
180 print(row.id,row.title,session.query(Users).filter(Users.user_type_id==row.id).all())
181182 type_list=session.query(UserType)
183for row in type_list:
184 print(row.id,row.title)
185for li in row.xxoo:
186 list=li.name
187 print(list)
188189 session.close()
1
from sqlalchemy.ext.declarative import declarative_base
2
from sqlalchemy import Column,Integer,String,ForeignKey,UniqueConstraint,Index,VARCHAR
3
from sqlalchemy.orm import sessionmaker,relationship
4
from sqlalchemy import create_engine
5
6 Base=declarative_base()
7 8class UserType(Base):
9 __tablename__=‘usertype‘
10 id = Column(Integer,primary_key=True,autoincrement=True)
11 title=Column(VARCHAR(32),nullable=True,index=True)
121314class Users(Base):
15 __tablename__=‘users‘
16 id=Column(Integer,primary_key=True,autoincrement=True)
17 name=Column(String(32),nullable=True,index=True)
18 email=Column(String(16),unique=True)
19 user_type_id = Column(Integer,ForeignKey(‘usertype.id‘))
2021 user_type=relationship(‘UserType‘,backref=‘xxoo‘)
2223 __table_args__ = (
24 UniqueConstraint(‘id‘,‘name‘,name=‘uni_id_name‘),
25 Index(‘ix_n_ma‘,‘name‘,‘email‘)
26 )
27#创建引擎 引擎调用dialect来选择相应的模块来操作数据库
28 engine=create_engine(‘mysql+pymysql://root:123@127.0.0.1:3306/db1?charset=utf8‘,max_overflow=5)
29Base.metadata.create_all(engine) # 创建模块中所有继承base的class的表
3031 Session= sessionmaker(bind=engine) # 从连接池中取得一个连接
32 session=Session()
333435 result=session.query(UserType.id,session.query(Users.name).filter(Users.id==1).as_scalar())
36print(result)
37for row in result:
38 print(row[0])
39404142 result1=session.query(UserType.id,session.query(Users.name).filter(Users.user_type_id==UserType.id,Users.name==‘alex‘).as_scalar())
43print(result1)
44for row in result1:
45 print(row[0])
-- 便利的功能 （relationship）
sqlAchemy:
是python编程语言下的一款ORM框架，该框架建立在数据库API之上，使用关系对象映射进行数据库操作
简言之，就是将对象转换成sql,然后使用数据库API执行sql并获取执行结果。
它本身无法操作数据库，必须用pymysql等第三方插件，dialect用于和数据库api进行交流，根据配置文件的不同
调用不同的数据库API，从而实现对数据库的操作。
使用 Engine/ConnectionPooling/Dialect 进行sql语句转换，Engine使用ConnectionPooling连接数据库
三种操作数据库的方式：
mysql客户端：终端 Navicat
pymysql :自己写sql语句
sqlAchemy：面向对象操作
简述ORM的运作与原理
对于用户来说：不用写sql语句，让用户通过类和对象的方式以及内部提供的方法来操作数据库
对于框架来说：将类与对象转换为sql语句并执行
本质：可以识别不同类型的数据库和对应的不同的数据库api，将类和对象转换成相应的sql语句，通过第三方插件（数据库API）来连接数据库进行操作
补充：数据库设计：
基于用户权限管理：
参考表结构：
用户信息表
id（主键） name pwd
1 alex 123
权限表
id（主键） power
1 订单管理
2 用户管理
3 bug管理
用户权限表
id user(外键) power（外键）
1 1 1
2 1 3
程序：用户登录
基于角色的权限管理：
参考表结构：
用户信息表
id（主键） name pwd partment（外键）
1 alex 123 2
权限表
id（主键） power
1 订单管理
2 用户管理
3 bug管理
部门表（角色表）
id partment
1 财务部
2 it部门
3 运维部
部门权限表（角色权限管理）
id partment(外键) power（外键）
1 1 1
2 1 2
3 1 3
4 2 1
5 2 3
原文：http://www.cnblogs.com/liuguniang/p/7044387.html
内容总结
以上是互联网集市为您收集整理的mysql基础（六）之sqlAchemy全部内容，希望文章能够帮你解决mysql基础（六）之sqlAchemy所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。
内容备注
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。
内容手机端
扫描二维码推送至手机访问。
来源：【匿名】