MySQL学习笔记（六）
好耶，七天课程的最后一天！我当然还没精通了，，，之后可能是多练习题目然后再学学其他的东西吧。mysql新的知识点也会在后面补充的。
一、杂七杂八补充
1. 当多个函数共用同样的参数时，可以转变成类进行。
面向对象：数据与逻辑组合在一起
函数编程：数据与逻辑分离
#进行意会的伪代码 class SqlHelper: def __init__(self): #需要重复使用的数据， 在__init__里面封装多个函数需要共同使用的东西 self.host = '' self.port ='' self.db ='' self.charset='' def exc1(self,SQL): # 连接 conn(self.host,) execute(SQL) return xx def exc2(self,proc_name): callproc(proc_name) return xxx
2. 类：提取共性。
一类事物共同具有的属性和行为。如一张表里面如果只有id与name两列，那么对表的操作一定是对这两列的操作（额，我Python不知道如何对类进行操作，等我学了对类的操作后，我再返回来检查一下这里的代码）
class Userinfo: def __init__(self,id,name): #约束’每个对象中只有两个字段，即：每个行数据都有id和name列 self.id = id self.name= name def add(self,name): pass # row1 = UserInfo(1,'alex') # 第一行 # row2 = UserInfo(2,'alex') # 第二行
3. 每一个对象里面具体的特殊方法（我服了，云里雾里就是我！我还会再回来的！）
class Foo: def __init__(self,name): self.name = name def show(self): print(self.name) def __call__(self): pass def __getitem__(self,key): pass def __setitem__(self,key,value): pass def __delitem__(self,key): pass obj1 = Foo('eric') obj1() #这个是Python中的特殊用法 obj1['k'] obj1['k'] = 123 del obj[k] #删除 obj.__dict__
二、ORM框架：SQLAlchemy
1. 作用：提供简单规则，自动转换成SQL语句。
2. 两类框架
（1）DB first
先手动创建数据库与表，根据数据库里面的表自动生成类
（2）code first
手动创建类与数据库，自动生成与表（ORM所属类别）
3. 功能
（1）创建数据库表
from sqlalchemy import create_engine from sqlalchemy.ext.declarative import declarative_base from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Index,CHAR,VARCHAR from sqlalchemy.orm import sessionmaker, relationship Base = declarative_base() # 创建单表——users继承base class UserType(Base): __tablename__ = 'usertype' #下面的三个变量创建好后会自动变到__init__里面，成为类里面的通用变量 id = Column(Integer, primary_key=True, autoincrement=True) title = Column(String(32), nullable=True, index=True) class Users(Base): __tablename__ = 'users' #下面的三个变量创建好后会自动变到__init__里面，成为类里面的通用变量 id = Column(Integer, primary_key=True, autoincrement=True) name = Column(String(32), nullable=True, index=True, default='sf') email = Column(String(16), nullable=True, unique=True) #unique=True表示建立唯一索引 #创建主键 user_type_id = Column(Integer,ForeignKey("usertype.id")) #设定规则 __table_args__ = ( UniqueConstraint('id', 'name', name='uix_id_name'), #id与name当成联合唯一索引，名字叫'uix_id_name' Index('ix_id_name','name', 'email'), #建立普通索引,名字叫'ix_id_name'，注意，名字要写在前面 ) #将创建表封装成函数 def create_db(): #max_overflow表示最多与数据库建立5个链接，最多可以发五条信息，实际上就是指“connection pool”这个连接池 engine = create_engine("mysql+pymysql://root:@localhost:3306/s7day", max_overflow = 5) #找到py文件中继承了base的类，创建表 Base.metadata.create_all(engine) #将删除表封装成函数 def drop_db(): engine = create_engine("mysql+pymysql://root:@localhost:3306/s7day", max_overflow=5) #默认会把base类对应的表都删掉 Base.metadata.drop_all(engine)
#调用时
create_db()
drop_db()
a.链接数据库（不是SQLAlchemy处理的，是pymysql/mysqlDB处理的）
b.把类转换成sql语句进行操作（SQLAlchemy进行语句的转换，然后提交给给pymysql进行处理）
#SQLAlchemy本身无法操作数据库，其必须以来pymsql等第三方插件，Dialect用于和数据API进行交流，根据配置文件的不同调用不同的数据库API，从而实现对数据库的操作，如： #MySQL-Python mysql+mysqldb://<user>:<password>@<host>[:<port>]/<dbname> #pymysql mysql+pymysql://<username>:<password>@<host>/<dbname>[?<options>] #MySQL-Connector mysql+mysqlconnector://<user>:<password>@<host>[:<port>]/<dbname> #cx_Oracle oracle+cx_oracle://user:pass@host:port/dbname[?key=value&key=value...] 更多详见：http://docs.sqlalchemy.org/en/latest/dialects/index.html
（2）操作数据行
a. 增
#创建连接 engine = create_engine("mysql+pymysql://root:@localhost:3306/s7day", max_overflow=5) Session = sessionmaker(bind = engine) #从5个连接中取出一个链接 session = Session() #类代指表，对象代指一行数据 #增加用户——一条增加 obj1 = UserType(title="bbb") session.add(obj1) #转换成sql语句 #增加用户——多条增加 objs = [ UserType(title="普通用户1"), UserType(title="普通用户2"), UserType(title="普通用户3") ] session.add_all(objs) session.commit()
b. 查
#创建连接 engine = create_engine("mysql+pymysql://root:@localhost:3306/s7day", max_overflow=5) Session = sessionmaker(bind = engine) #从5个连接中取出一个链接 session = Session() #查询数据——类是表的含义，所以要去类里面查询 # print(session.query(UserType)) #输出的是SQL语句SELECT usertype.id AS usertype_id, usertype.title AS usertype_title FROM usertype usertype_list = session.query(UserType).all() # print(usertype_list) #输出是列表，列表里面是对象，即数据行 for row in usertype_list: print(row.id, row.title) #得到用户具体信息 #查询筛选 usertype_list = session.query().filter(UserType.id > 2) #全部返回 for row in usertype_list: print(row.id, row.title) usertype_list = session.query(usertype_list.id).filter(UserType.id > 2) #只返回id session.close()
c. 删
#创建连接 engine = create_engine("mysql+pymysql://root:@localhost:3306/s7day", max_overflow=5) Session = sessionmaker(bind = engine) #从5个连接中取出一个链接 session = Session() #删除数据前要先查找到需要删除的数据 usertype_list = session.query(UserType).filter(UserType.id>2).delete() #将查询到的全部删除（可以不赋值给一个变量） # for row in usertype_list: # print(row.id, row.title) print(usertype_list) #返回的是删除的条数 session.commit() session.close()
d. 改——更新
#更新输入的是字典 #整体修改成一样的值 session.query(UserType).filter(UserTpye.id > 2).update({"title" : "099"}) #字符拼接拼接：在原来的title的基础上加“099” session.query(UserType).filter(UserType.id > 2).update({UserType.title: UserType.title + "099"}, synchronize_session=False) #在原来数值的基础上+1 session.query(UserType).filter(UserType.id > 2).update({"num": UserType.num + 1}, synchronize_session="evaluate") session.commit() e. 其他汇总 # 条件 ret = session.query(Users).filter_by(name='alex').all() #括号内传的是参数，在内部会调用filter ret = session.query(Users).filter(Users.id > 1, Users.name == 'eric').all() #k括号内传的是表达式 ret = session.query(Users).filter(Users.id.between(1, 3), Users.name == 'eric').all() ret = session.query(Users).filter(Users.id.in_([1,3,4])).all() ret = session.query(Users).filter(~Users.id.in_([1,3,4])).all() #~指not in ret = session.query(Users).filter(Users.id.in_(session.query(Users.id).filter_by(name='eric'))).all() from sqlalchemy import and_, or_ ret = session.query(Users).filter(and_(Users.id > 3, Users.name == 'eric')).all() ret = session.query(Users).filter(or_(Users.id < 2, Users.name == 'eric')).all() ret = session.query(Users).filter( or_( Users.id < 2, and_(Users.name == 'eric', Users.id > 3), Users.extra != "" )).all() # 通配符 ret = session.query(Users).filter(Users.name.like('e%')).all() ret = session.query(Users).filter(~Users.name.like('e%')).all() #~表示对立面 # 限制 ret = session.query(Users)[1:2] #其实就是limit # 排序 ret = session.query(Users).order_by(Users.name.desc()).all() ret = session.query(Users).order_by(Users.name.desc(), Users.id.asc()).all() # 分组 from sqlalchemy.sql import func ret = session.query(Users).group_by(Users.extra).all() ret = session.query( func.max(Users.id), #聚合函数 func.sum(Users.id), func.min(Users.id)).group_by(Users.name).all() ret = session.query( func.max(Users.id), func.sum(Users.id), func.min(Users.id)).group_by(Users.name).having(func.min(Users.id) >2).all() # 连表 #将Users, UserType两张表以笛卡尔积的形式进行链接，返回的是两张表的所有数据，不存在链接关键词 #SELECT users.id AS users_id, users.name AS users_name, users.email AS users_email, users.user_type_id AS users_user_type_id, usertype.num AS usertype_num, usertype.id AS usertype_id, usertype.title AS usertype_title FROM users, usertype ret = session.query(Users, UserType) #相当于inner join，没有空值 #SELECT users.id AS users_id, users.name AS users_name, users.email AS users_email, users.user_type_id AS users_user_type_id, usertype.num AS usertype_num, usertype.id AS usertype_id, usertype.title AS usertype_title FROM users, usertype WHERE users.id = usertype.id ret = session.query(Users, UserType).filter(Users.id == UserType.id).all() #相当于inner join， 在两张表有外键关系的情况下，不用设置链接列 ret = session.query(Users).join(UserType).all() #相当于left join ret = session.query(Users).join(UserType, isouter=True).all() # 组合 q1 = session.query(Users.name).filter(Users.id > 2) q2 = session.query(Favor.caption).filter(Favor.nid < 2) ret = q1.union(q2).all() q1 = session.query(Users.name).filter(Users.id > 2) q2 = session.query(Favor.caption).filter(Favor.nid < 2) ret = q1.union_all(q2).all() #不去重 #子查询 #1.select * from usertype where id in (select id from usertype.user_name = 'alex') session.query(UserType).filter( UserType.id.in_(session.query(Users.id).filter(Users.name == 'alex')) ).all() #2. 临时表类型——select * from (select * from usertype where id > 2) as B session.query(session.query(UserType).filter(UserType.id > 2).subquery()) #重点在于这个subquery() #3. select id, (select * from usertype) from users result = session.query(Users.id, Users.name, session.query(UserType.title).filter(Users.user_type_id==UserType.id).as_scalar()) #重点在于这个as_scalar()
4. SQLAlchemy中的relationship（***）
relationship写在有foreign key的类中
问题一：获取用户信息以及与其关联的用户类型名称
#解决方法一：使用连表操作 user_list = session.query(Users,UserType).join(UserType,isouter=True) print(user_list) for row in user_list: print(row[0].id,row[0].name,row[0].email,row[0].user_type_id,row[1].title) user_list = session.query(Users.name,UserType.title).join(UserType,isouter=True).all() #不加all也能拿，不加all相当于一个迭代器，一次一次拿，加上all一下子拿完 for row in user_list: print(row)
解决方案一
#解决方案二 #在创建数据表时设立relationship class Users(Base): __tablename__ = 'users' id = Column(Integer, primary_key=True, autoincrement=True) name = Column(VARCHAR(32), nullable=True, index=True) email = Column(VARCHAR(16), unique=True) user_type_id = Column(Integer,ForeignKey("usertype.id")) user_type = relationship("UserType",backref='xxoo') ) type_list = session.query(Users) for row in type_list: print(row.id,row.name,user_type.title)
解决方案二
问题二：获取不同用户类型下的用户
#解决方法一 type_list = session.query(UserType) for row in type_list: print(row.id,row.title,session.query(Users).filter(Users.user_type_id == row.id).all())
解决方法一
#解决方法二 class Users(Base): __tablename__ = 'users' id = Column(Integer, primary_key=True, autoincrement=True) name = Column(VARCHAR(32), nullable=True, index=True) email = Column(VARCHAR(16), unique=True) user_type_id = Column(Integer,ForeignKey("usertype.id")) user_type = relationship("UserType",backref='xxoo') "xxoo"是提供给usertype使用的 ) type_list = session.query(UserType) for row in type_list: print(row.id,row.title,row.xxoo)
解决方案二
relationship中的“正向操作”与反向操作
版权声明：本文为myra-dream原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。