sqlalchemy ORM

sqlalchemy  ORM

一、ORM

　　orm英文全称object relational mapping,即对象映射关系程序。

　　在Python这种面向对象的编程语言中，一切皆对象，但当我们使用关系型数据库时，为了保证一致性的使用习惯，通过orm将编程语言的对象模型和数据库的关系模型建立映射关系，这样我们在使用编程语言对数据库进行操作的时候可以直接使用编程语言的对象模型进行操作就可以了，而不用直接使用sql语言，大大提高了编程效率。

　　orm的优点：

　　1、隐藏了数据访问细节，“封闭”的通用数据库交互，ORM的核心。他使得我们的通用数据库交互变得简单易行，并且完全不用考虑该死的SQL语句。快速开发，由此而来。

　　2、ORM使我们构造固化数据结构变得简单易行。

　　缺点：

　　1、无可避免的，自动化意味着映射和关联管理，代价是牺牲性能（早期，这是所有不喜欢ORM人的共同点）。现在的各种ORM框架都在尝试使用各种方法来减轻这块（LazyLoad，Cache），效果还是很显著的。

　　ORM与数据库和程序之间的关系图：

大概流程：

#1、使用者通过ORM对象提交命令
#2、将命令交给SQLAlchemy Core（Schema/Types  SQL Expression Language）转换成SQL
#3、使用 Engine/ConnectionPooling/Dialect 进行数据库操作
#3.1、匹配使用者事先配置好的egine
#3.2、egine从连接池中取出一个链接
#3.3、基于该链接通过Dialect调用DB API，将SQL转交给它去执行
View Code

　　DB API

　　SQLAlchemy本身无法操作数据库，其必须以来pymsql等第三方插件，Dialect用于和数据API进行交流，根据配置文件的不同调用不同的数据库API，从而实现对数据库的操作，如：

#1、MySQL-Python
    mysql+mysqldb://<user>:<password>@<host>[:<port>]/<dbname>
   
#2、pymysql
    mysql+pymysql://<username>:<password>@<host>/<dbname>[?<options>]
   
#3、MySQL-Connector
    mysql+mysqlconnector://<user>:<password>@<host>[:<port>]/<dbname>
   
#4、cx_Oracle
    oracle+cx_oracle://user:pass@host:port/dbname[?key=value&key=value...]

二、创建表关系

　　ORM中：

　　#类===>表

　　#对象==>表中的一行记录

　　四张表:业务线,服务,用户,角色，利用ORM创建出它们，并建立好它们直接的关系　　

from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column,Integer,String,DateTime,Enum,ForeignKey,UniqueConstraint,ForeignKeyConstraint,Index
from sqlalchemy.orm import sessionmaker

egine=create_engine('mysql+pymysql://root@127.0.0.1:3306/db1?charset=utf8',max_overflow=5)

Base=declarative_base()

#创建单表:业务线
class Business(Base):
    __tablename__='business'
    id=Column(Integer,primary_key=True,autoincrement=True)
    bname=Column(String(32),nullable=False,index=True)

#多对一:多个服务可以属于一个业务线,多个业务线不能包含同一个服务
class Service(Base):
    __tablename__='service'
    id=Column(Integer,primary_key=True,autoincrement=True)
    sname=Column(String(32),nullable=False,index=True)
    ip=Column(String(15),nullable=False)
    port=Column(Integer,nullable=False)

    business_id=Column(Integer,ForeignKey('business.id'))

    __table_args__=(
        UniqueConstraint(ip,port,name='uix_ip_port'),
        Index('ix_id_sname',id,sname)
    )

#一对一:一种角色只能管理一条业务线,一条业务线只能被一种角色管理
class Role(Base):
    __tablename__='role'
    id=Column(Integer,primary_key=True,autoincrement=True)
    rname=Column(String(32),nullable=False,index=True)
    priv=Column(String(64),nullable=False)

    business_id=Column(Integer,ForeignKey('business.id'),unique=True)


#多对多:多个用户可以是同一个role,多个role可以包含同一个用户
class Users(Base):
    __tablename__='users'
    id=Column(Integer,primary_key=True,autoincrement=True)
    uname=Column(String(32),nullable=False,index=True)


class Users2Role(Base):
    __tablename__='users2role'
    id=Column(Integer,primary_key=True,autoincrement=True)
    uid=Column(Integer,ForeignKey('users.id'))
    rid=Column(Integer,ForeignKey('role.id'))

    __table_args__=(
        UniqueConstraint(uid,rid,name='uix_uid_rid'),
    )


def init_db():
    Base.metadata.create_all(egine)

def drop_db():
    Base.metadata.drop_all(egine)

if __name__ == '__main__':
    init_db()
View Code

　　注：设置外键的另一种方式 ForeignKeyConstraint(['other_id'], ['othertable.other_id'])

三 增删改查

表结构

 1 from sqlalchemy import create_engine
 2 from sqlalchemy.ext.declarative import declarative_base
 3 from sqlalchemy import Column,Integer,String,ForeignKey
 4 from sqlalchemy.orm import sessionmaker
 5 
 6 egine=create_engine('mysql+pymysql://root@127.0.0.1:3306/db1?charset=utf8',max_overflow=5)
 7 
 8 Base=declarative_base()
 9 
10 
11 #多对一:假设多个员工可以属于一个部门,而多个部门不能有同一个员工(只有创建公司才把员工当骆驼用,一个员工身兼数职)
12 class Dep(Base):
13     __tablename__='dep'
14     id=Column(Integer,primary_key=True,autoincrement=True)
15     dname=Column(String(64),nullable=False,index=True)
16 
17 class Emp(Base):
18     __tablename__='emp'
19     id=Column(Integer,primary_key=True,autoincrement=True)
20     ename=Column(String(32),nullable=False,index=True)
21     dep_id=Column(Integer,ForeignKey('dep.id'))
22 
23 def init_db():
24     Base.metadata.create_all(egine)
25 
26 def drop_db():
27     Base.metadata.drop_all(egine)
28 
29 drop_db()
30 init_db()
31 Session=sessionmaker(bind=egine)
32 session=Session()
View Code

增

 1 #增
 2 row_obj=Dep(dname='销售') #按关键字传参,无需指定id,因其是自增长的
 3 session.add(row_obj)
 4 session.add_all([
 5     Dep(dname='技术'),
 6     Dep(dname='运营'),
 7     Dep(dname='人事'),
 8 ])
 9 
10 session.commit()
View Code

删

1 #删
2 session.query(Dep).filter(Dep.id > 3).delete()
3 session.commit()
View Code

改

1 #改
2 session.query(Dep).filter(Dep.id > 0).update({'dname':'哇哈哈'})
3 session.query(Dep).filter(Dep.id > 0).update({'dname':Dep.dname+'_SB'},synchronize_session=False)
4 session.query(Dep).filter(Dep.id > 0).update({'id':Dep.id*100},synchronize_session='evaluate')
5 
6 session.commit()
View Code

查

 1 #查所有,取所有字段
 2 res=session.query(Dep).all() #for row in res:print(row.id,row.dname)
 3 
 4 #查所有,取指定字段
 5 res=session.query(Dep.dname).order_by(Dep.id).all() #for row in res:print(row.dname)
 6 
 7 res=session.query(Dep.dname).first()
 8 print(res) # ('哇哈哈_SB',)
 9 
10 #过滤查
11 res=session.query(Dep).filter(Dep.id > 1,Dep.id <1000) #逗号分隔,默认为and
12 print([(row.id,row.dname) for row in res])
View Code

四 其他查询相关

（1）表和数据

 1 from sqlalchemy import create_engine
 2 from sqlalchemy.ext.declarative import declarative_base
 3 from sqlalchemy import Column,Integer,String,ForeignKey
 4 from sqlalchemy.orm import sessionmaker
 5 
 6 egine=create_engine('mysql+pymysql://root@127.0.0.1:3306/db1?charset=utf8',max_overflow=5)
 7 
 8 Base=declarative_base()
 9 
10 
11 #多对一:假设多个员工可以属于一个部门,而多个部门不能有同一个员工(只有创建公司才把员工当骆驼用,一个员工身兼数职)
12 class Dep(Base):
13     __tablename__='dep'
14     id=Column(Integer,primary_key=True,autoincrement=True)
15     dname=Column(String(64),nullable=False,index=True)
16 
17 class Emp(Base):
18     __tablename__='emp'
19     id=Column(Integer,primary_key=True,autoincrement=True)
20     ename=Column(String(32),nullable=False,index=True)
21     dep_id=Column(Integer,ForeignKey('dep.id'))
22 
23 def init_db():
24     Base.metadata.create_all(egine)
25 
26 def drop_db():
27     Base.metadata.drop_all(egine)
28 
29 drop_db()
30 init_db()
31 Session=sessionmaker(bind=egine)
32 session=Session()
33 
34 # 准备数据
35 session.add_all([
36     Dep(dname='技术'),
37     Dep(dname='销售'),
38     Dep(dname='运营'),
39     Dep(dname='人事'),
40 ])
41 
42 session.add_all([
43     Emp(ename='林海峰',dep_id=1),
44     Emp(ename='李杰',dep_id=1),
45     Emp(ename='武配齐',dep_id=1),
46     Emp(ename='元昊',dep_id=2),
47     Emp(ename='李钢弹',dep_id=3),
48     Emp(ename='张二丫',dep_id=4),
49     Emp(ename='李坦克',dep_id=2),
50     Emp(ename='王大炮',dep_id=4),
51     Emp(ename='牛榴弹',dep_id=3)
52 ])
53 
54 session.commit()
View Code

（2）二 条件、通配符、limit、排序、分组、连表、组合

 1 #一、条件
 2 sql=session.query(Emp).filter_by(ename='林海峰') #filter_by只能传参数:什么等于什么
 3 res=sql.all() #sql语句的执行结果
 4 
 5 res=session.query(Emp).filter(Emp.id>0,Emp.ename == '林海峰').all() #filter内传的是表达式,逗号分隔,默认为and,
 6 res=session.query(Emp).filter(Emp.id.between(1,3),Emp.ename == '林海峰').all()
 7 res=session.query(Emp).filter(Emp.id.in_([1,3,99,101]),Emp.ename == '林海峰').all()
 8 res=session.query(Emp).filter(~Emp.id.in_([1,3,99,101]),Emp.ename == '林海峰') #~代表取反,转换成sql就是关键字not
 9 
10 from sqlalchemy import and_,or_
11 res=session.query(Emp).filter(and_(Emp.id > 0,Emp.ename=='林海峰')).all()
12 res=session.query(Emp).filter(or_(Emp.id < 2,Emp.ename=='功夫熊猫')).all()
13 res=session.query(Emp).filter(
14     or_(
15         Emp.dep_id == 3,
16         and_(Emp.id > 1,Emp.ename=='功夫熊猫'),
17         Emp.ename != ''
18     )
19 ).all()
20 
21 
22 #二、通配符
23 res=session.query(Emp).filter(Emp.ename.like('%海_%')).all()
24 res=session.query(Emp).filter(~Emp.ename.like('%海_%')).all()
25 
26 #三、limit
27 res=session.query(Emp)[0:5:2]
28 
29 #四、排序
30 res=session.query(Emp).order_by(Emp.dep_id.desc()).all()
31 res=session.query(Emp).order_by(Emp.dep_id.desc(),Emp.id.asc()).all()
32 
33 #五、分组
34 from sqlalchemy.sql import func
35 
36 res=session.query(Emp.dep_id).group_by(Emp.dep_id).all()
37 res=session.query(
38     func.max(Emp.dep_id),
39     func.min(Emp.dep_id),
40     func.sum(Emp.dep_id),
41     func.avg(Emp.dep_id),
42     func.count(Emp.dep_id),
43 ).group_by(Emp.dep_id).all()
44 
45 
46 res=session.query(
47     Emp.dep_id,
48     func.count(1),
49 ).group_by(Emp.dep_id).having(func.count(1) > 2).all()
50 
51 
52 #六、连表
53 #笛卡尔积
54 res=session.query(Emp,Dep).all() #select * from emp,dep;
55 
56 #where条件
57 res=session.query(Emp,Dep).filter(Emp.dep_id==Dep.id).all()
58 # for row in res:
59 #     emp_tb=row[0]
60 #     dep_tb=row[1]
61 #     print(emp_tb.id,emp_tb.ename,dep_tb.id,dep_tb.dname)
62 
63 #内连接
64 res=session.query(Emp).join(Dep)
65 #join默认为内连接,SQLAlchemy会自动帮我们通过foreign key字段去找关联关系
66 #但是上述查询的结果均为Emp表的字段,这样链表还有毛线意义,于是我们修改为
67 res=session.query(Emp.id,Emp.ename,Emp.dep_id,Dep.dname).join(Dep).all()
68 
69 #左连接:isouter=True
70 res=session.query(Emp.id,Emp.ename,Emp.dep_id,Dep.dname).join(Dep,isouter=True).all()
71 
72 #右连接:同左连接,只是把两个表的位置换一下
73 
74 
75 #七、组合
76 q1=session.query(Emp.id,Emp.ename).filter(Emp.id > 0,Emp.id < 5)
77 q2=session.query(Emp.id,Emp.ename).filter(
78     or_(
79         Emp.ename.like('%海%'),
80         Emp.ename.like('%昊%'),
81     )
82 )
83 res1=q1.union(q2) #组合+去重
84 res2=q1.union_all(q2) #组合,不去重
85 
86 print([i.ename for i in q1.all()]) #['林海峰', '李杰', '武配齐', '元昊']
87 print([i.ename for i in q2.all()]) #['林海峰', '元昊']
88 print([i.ename for i in res1.all()]) #['林海峰', '李杰', '武配齐', '元昊']
89 print([i.ename for i in res2.all()]) #['林海峰', '李杰', '武配齐', '元昊', '元昊', '林海峰']
View Code

（3） 子查询

注：有三种形式的子查询，注意：子查询的sql必须用括号包起来,尤其在形式三中需要注意这一点

形式一:子查询当做一张表来用,调用subquery()
形式二:子查询当做in的范围用,调用in_
形式三:子查询当做select后的字段,调用as_scalar()

五 正查、反查

（1）表修改

 1 from sqlalchemy import create_engine
 2 from sqlalchemy.ext.declarative import declarative_base
 3 from sqlalchemy import Column,Integer,String,ForeignKey
 4 from sqlalchemy.orm import sessionmaker,relationship
 5 
 6 egine=create_engine('mysql+pymysql://root@127.0.0.1:3306/db1?charset=utf8',max_overflow=5)
 7 
 8 Base=declarative_base()
 9 
10 class Dep(Base):
11     __tablename__='dep'
12     id=Column(Integer,primary_key=True,autoincrement=True)
13     dname=Column(String(64),nullable=False,index=True)
14 
15 class Emp(Base):
16     __tablename__='emp'
17     id=Column(Integer,primary_key=True,autoincrement=True)
18     ename=Column(String(32),nullable=False,index=True)
19     dep_id=Column(Integer,ForeignKey('dep.id'))
20 
21     #在ForeignKey所在的类内添加relationship的字段,注意:
22     #1:Dep是类名
23     #2:depart字段不会再数据库表中生成字段
24     #3:depart用于Emp表查询Dep表(正向查询),而xxoo用于Dep表查询Emp表(反向查询),
25     depart=relationship('Dep',backref='xxoo') 
26 
27 def init_db():
28     Base.metadata.create_all(egine)
29 
30 def drop_db():
31     Base.metadata.drop_all(egine)
32 
33 drop_db()
34 init_db()
35 Session=sessionmaker(bind=egine)
36 session=Session()
37 
38 # 准备数据
39 session.add_all([
40     Dep(dname='技术'),
41     Dep(dname='销售'),
42     Dep(dname='运营'),
43     Dep(dname='人事'),
44 ])
45 
46 session.add_all([
47     Emp(ename='林海峰',dep_id=1),
48     Emp(ename='李杰',dep_id=1),
49     Emp(ename='武配齐',dep_id=1),
50     Emp(ename='元昊',dep_id=2),
51     Emp(ename='李钢弹',dep_id=3),
52     Emp(ename='张二丫',dep_id=4),
53     Emp(ename='李坦克',dep_id=2),
54     Emp(ename='王大炮',dep_id=4),
55     Emp(ename='牛榴弹',dep_id=3)
56 ])
57 
58 session.commit()
View Code

（2）标准连表查询

1 # 示例:查询员工名与其部门名
2 res=session.query(Emp.ename,Dep.dname).join(Dep) #迭代器
3 for row in res:
4     print(row[0],row[1]) #等同于print(row.ename,row.dname)
View Code

（3） 基于relationship的正查、反查

 1 #SQLAlchemy的relationship在内部帮我们做好表的链接
 2 
 3 #查询员工名与其部门名(正向查)
 4 res=session.query(Emp)
 5 for row in res:
 6     print(row.ename,row.id,row.depart.dname)
 7 
 8 
 9 #查询部门名以及该部门下的员工(反向查)
10 res=session.query(Dep)
11 for row in res:
12     # print(row.dname,row.xxoo)
13     print(row.dname,[r.ename for r in row.xxoo])
View Code

本文转载自：http://www.cnblogs.com/linhaifeng/articles/7560153.html

【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/hzauq/p/8454297.html