mysql基础之sqlAchemy

Posted 2020-09-23 柳姑娘

函数编程：数据和逻辑分离
        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:123@127.0.0.1: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:123@127.0.0.1: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