mysql基础(六)之sqlAchemy

参考博客: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()


 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
 
时间: 2024-10-29 02:11:58

mysql基础(六)之sqlAchemy的相关文章

MySQL基础六

1 变量 1.1 变量的分类 系统变量: 全局变量: 会话变量: 自定义变量: 用户变量: 局部变量: 1.2 系统变量 1.2.1 系统变量的基本介绍 变量是由系统提供的,不是用户定义,属于服务器层面. 1.2.2 系统变量的使用 查看所有的系统变量 -- global表示全局 -- session表示回话 show global|session variables; 查看满足条件的部分变量 -- global表示全局 -- session表示回话 show global|session va

mysql基础itcast笔记

1. 课程回顾 mysql基础 1)mysql存储结构: 数据库 -> 表 -> 数据   sql语句 2)管理数据库: 增加: create database 数据库 default character utf8; 删除: drop database 数据库; 修改: alter database 数据库 default character gbk; 查询: show databases / show create database 数据库; 3) 管理表: 选择数据库:use 数据库; 增

MySQL基础知识

MySQL基础知识: 一. 知识点:        1. SQL分类:按照其功能不同,分为3中类别           DDL(Data Defintion Language):数据定义语句,用于定义不同的数据段.数据库.表.列.索引等.常用的语句关键字包括create.drop.alter等;             DML(Data Manipulation Language):数据操纵语句,用于添加.删除.更新和查询数据库记录,并检查数据的完整性.常用的语句关键字主要包括insert.de

MySQL基础2

1. 课程回顾mysql基础 1)mysql存储结构: 数据库 -> 表 -> 数据 sql语句 2)管理数据库: 增加: create database 数据库 default character utf8; 删除: drop database 数据库; 修改: alter database 数据库 default character gbk; 查询: show databases / show create database 数据库; 3) 管理表: 选择数据库:use 数据库; 增加:

趁一切还来得及【一】数据库MySQL基础知识及编译安装

此情更待成追忆,只是当时已惘然.                                        --[唐]李商隐 第一章 数据库概述及分类特点应用 1.1 数据库种类.语言处理.典型产品 ①数据库的理解:就是一个存放数据的仓库,这个仓库是按照一定的数据结构,来组织和存储的.可以通过数据库提供的多种方法来管理数据库. ②数据库的种类:按照早期的数据库理论分为层次数据库.网络式数据库.和关系型数据库.当今互联网最常用的就是关系型数据库和非关系型数据库(NOSQL). ③关系型数据库:

MYSQL 基础操作

1.MySQL基础操作 一:MySQL基础操作 1:MySQL表复制 复制表结构 + 复制表数据 create table t3 like t1; --创建一个和t1一样的表,用like(表结构也一样) insert into t3 select * from t1; --t1的数据全部拿过来,注意是表结构一致才select* ,否则选择相应的的字段列插入 create table t1( id int unsigned not null auto_increment primary key,

如鹏网学习笔记(五)MySql基础

MySQL基础 一.数据库概念 1,网友装备信息.论坛帖子信息.QQ好友关系信息.学籍管理系统中的学生信息等都要"持久化"的保存到一个地方, 如果通过IO写到文件中,那么会非常麻烦,而且不利于多人共享数据 2,我们开发大部分软件.网站都要大量用到书库,甚至开发游戏.手机App也要用到数据库,公司面试的时候数据库的考核在三分之一以上 3,数据库(DataBase)是保存数据的仓库,可以方便的把数据放进去,并且把数据根据各种需要取出来. 数据库管理系统(Database Managemen

04 mysql 基础三 (进阶)

mysql 基础三 阶段一 mysql 单表查询 1.查询所有记录 select * from department; ? select * from student; ? select * from student_detail; 2.查询选中列记录 select s_name from student; 3.查询指定条件下的记录 select s_name from student where s_id>2; 4.查询后为列取别名 select s_name as 姓名 from stude

MySQL基础实战

一.数据库基础: DBMS:数据库管理系统(Database Management System) RDBMS:关系数据库管理系统(Relational Database Management System) C/S:通过专有协议 关系模型:表(行,列),二维关系 范式:第一范式,第二范式,第三范式: 关系运算: 选择 投影 数据库:表,索引,视图(虚表) SQL:结构化查询语言 DDL:数据定义语言 DML:数据操作语言 编程接口: 自行定义存储过程 自行定义存储函数 触发器: 时间调度器:类

【夯实Mysql基础】记一次mysql语句的优化过程!

1. [事件起因] 今天在做项目的时候,发现提供给客户端的接口时间很慢,达到了2秒多,我第一时间,抓了接口,看了运行的sql,发现就是 2个sql慢,分别占了1秒多. 一个sql是 链接了5个表同时使用了 2个 order by和 1个limit的分页 sql. 一个sql是上一个sql的count(*),即链接了5个表,当然没有limit了(取总数). 2. [着手优化] 1)[优化思路] 第一条是 做client调用 service层的数据缓存 第二条就是 优化sql本身. 这里着重讲一下