mysql基礎（六）之sqlAchemy
阿新 • • 發佈：2017-06-18
true syn lte color 模塊 實例化 codefirst pow import 
參考博客：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 """ 9 1 白金 10 2 黑金 11 obj.xx ==> [obj,obj...] 12 """ 13 class 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 """ 19 1 方少偉 1 20 2 成套 1 21 3 小白 2 22 ut = relationship（backref=‘xx‘） 23 obj.ut ==> 1 白金 24 """ 25 class 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:[email protected]:3306/db1?charset=utf8‘,max_overflow=5) 41 Base.metadata.create_all(engine) # 創建模塊中所有繼承base的class的表 42 43 Session= sessionmaker(bind=engine) # 從連接池中取得一個連接 44 session=Session() # 實例化出來一個會話連接，session用於創建程序和數據庫之間的會話，所有對象的載入和保存都需要通過session對象 45 ###########增加######## 46 obj1=UserType(title=‘普通‘) 47 session.add(obj1) 48 49 objs=[ 50 UserType(title=‘超級‘), 51 UserType(title=‘白金‘), 52 UserType(title=‘黑金‘), 53 ] 54 session.add_all(objs) 55 session.commit() 56 57 ###########查找######## 58 print(session.query(UserType)) 59 user_type_list = session.query(UserType).all() 60 print(type(user_type_list[0])) # 對象 61 for 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() 66 session.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‘) 71 session.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‘) 82 for 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 87 from 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 # #分組 108 from sqlalchemy import func 109 ret = session.query(Users).group_by(Users.email).all() 110 111 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() 116 117 118 119 #連表的兩種方式: 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) 122 123 result=session.query(Users).join(UserType) 124 result1=session.query(Users).join(UserType,isouter=True) #相當於left join 125 print(result1) 126 127 128 ###########臨時表的用法########### 129 1 130 ret1=session.query(Users,UserType).filter(Users.user_type_id==UserType.id) 131 for 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() 136 print(result) 137 3 138 result=session.query(UserType.id,session.query(Users.id).as_scalar()) 139 print(result) 140 for row in result: 141 print(row[0]) 142 143 144 result1=session.query(UserType.id,session.query(Users).filter(Users.user_type_id==UserType.id).as_scalar()) 145 print(result1) 146 147 #組合 148 149 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() 152 print(ret) 153 154 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() 157 print(ret) 158 159 160 #########################relationship*************************** 161 # 問題：獲取用戶信息以及與其關聯的用戶類型名稱（fk,relationship ==> 正向操作） 162 user_list1=session.query(Users,UserType).join(UserType,isouter=True) 163 print(user_list1) 164 for row in user_list1: 165 print(row[0].id,row[0].name,row[0].email,row[0].user_type_id,row[1].title) 166 167 user_list2=session.query(Users.name,UserType.title).join(UserType,isouter=True).all() 168 print(user_list2) 169 for row in user_list2: 170 print(row.name,row.title) 171 172 user_list=session.query(Users) 173 for row in user_list: 174 print(row.id,row.name,row.user_type.title) 175 176 177 # 問題二：獲取用戶類型下的用戶名 反向操作 178 type_list1=session.query(UserType) 179 for row in type_list1: 180 print(row.id,row.title,session.query(Users).filter(Users.user_type_id==row.id).all()) 181 182 type_list=session.query(UserType) 183 for row in type_list: 184 print(row.id,row.title) 185 for li in row.xxoo: 186 list=li.name 187 print(list) 188 189 session.close()View Code
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 class UserType(Base): 9 __tablename__=‘usertype‘ 10 id = Column(Integer,primary_key=True,autoincrement=True) 11 title=Column(VARCHAR(32),nullable=True,index=True) 12 13 14 class 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‘)) 20 21 user_type=relationship(‘UserType‘,backref=‘xxoo‘) 22 23 __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:[email protected]:3306/db1?charset=utf8‘,max_overflow=5) 29 Base.metadata.create_all(engine) # 創建模塊中所有繼承base的class的表 30 31 Session= sessionmaker(bind=engine) # 從連接池中取得一個連接 32 session=Session() 33 34 35 result=session.query(UserType.id,session.query(Users.name).filter(Users.id==1).as_scalar()) 36 print(result) 37 for row in result: 38 print(row[0]) 39 40 41 42 result1=session.query(UserType.id,session.query(Users.name).filter(Users.user_type_id==UserType.id,Users.name==‘alex‘).as_scalar()) 43 print(result1) 44 for 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
mysql基礎（六）之sqlAchemy