前言# 第一部分:数据库练习
准备数据
创建数据表插入数据 SQL演练
1. SQL语句的强化2. 创建"商品分类"表3. 同步表数据4. 创建“商品品牌表”表5. 同步数据6. 修改表结构7. 外键
外键取消外键：其实在设计定义数据库的时候，就已经确定了要不要使用外键：比如下面的逻辑。 8. 其实就是多创建一个表，然后从原来的表上使用外键进行关联：下面代码可以一次性复制粘贴进行联系 # 第二部分：Python *** 作 MySQL
1. 初尝python与mysql交互2. pymysql查询数据库、面向对象3. pymysql添加数据库、面向对象4. 此处介绍`SQL注入`5.防止SQL注入 # 第三部分：MySQL高级
1. 视图
1.问题······6. 删除视图7. 视图demo8.视图的作用 2. 事务3. 索引4. 账户管理5. MySQL主从 后记
前言MySQL数据库的基本使用前面简单记录了下mysql，这篇文章主要的知识点是，如何用Python *** 作MySQL数据库首先，使用Python *** 作MySQL数据库,就需要有一个基本的数据库去 *** 作。因此，这篇文章的第一部分:数据库练习就是创建一个jingdong数据库；接下来，就是第二部分：Python *** 作 MySQL，用Python *** 作第一部分创建的数据库；最后，第三部分：MySQL高级，主要记录数据库设计的思想，什么是视图（虚表）、事务、索引、账户管理的思想、主从的思想。
推荐资料：
菜鸟：MySQL 教程MySQL笔记（pymysql）https://github.com/wmh02240/MySQL-Notes服务器及软件———MySQL数据库，可以浏览下这个博主的内容。菜鸟：python3-mysql视频：pymysql的使用B站：python和mysql视频，有口音，但是讲得还可以。 # 第一部分:数据库练习 准备数据 创建数据表
create database jingdong charset=utf8;
use jingdong;
-- 商品表
create table goods(
id int unsigned primary key auto_increment not null,
name varchar(150) not null,
cate_name varchar(40) not null,
brand_name varchar(50) not null,
price decimal(10,3) not null default 0,
is_show bit not null default 1,
is_saleoff bit not null default 0
);
插入数据
insert into goods values (0,'r510vc 15.6英寸笔记本','笔记本','华硕','3399',default,default),
(0,'y400n 14.0英寸笔记本电脑','笔记本','联想','4999',default,default),
(0,'g150th 15.6英寸笔记本','游戏本','雷神','8499',default,default),
(0,'x550cc 15.6英寸笔记本','笔记本','华硕','2799',default,default),
(0,'x240 超级本','超级本','联想','4880',default,default),
(0,'u330p 13.3英寸超级本','超级本','联想','4299',default,default),
(0,'svp13226scb 触控超级本','超级本','索尼','7999',default,default),
(0,'ipad mini 7.9英寸平板电脑','平板电脑','苹果','1998',default,default),
(0,'ipad air 9.7英寸平板电脑','平板电脑','苹果','3388',default,default),
(0,'ipad mini 配备retina显示屏','平板电脑','苹果','2788',default,default),
(0,'ideacentre c340 20英寸一体电脑','台式机','联想','3499',default,default),
(0,'vostro 3800-r1206 台式电脑','台式机','戴尔','2899',default,default),
(0,'imac me086ch/a 21.5英寸一体电脑','台式机','苹果','9188',default,default),
(0,'at7-7414lp 台式电脑 linux','台式机','苹果','3699',default,default),
(0,'z220sff f4f06pa工作站','服务器/工作站','惠普','4288',default,default),
(0,'powereedge ii服务器','服务器/工作站','戴尔','5388',default,default),
(0,'mac pro专业级台式电脑','服务器/工作站','苹果','28888',default,default),
(0,'hmz-t3w 头戴显示设备','笔记本配件','索尼','6999',default,default),
(0,'商务双肩背包','笔记本配件','索尼','99',default,default),
(0,'x3250 m4机架式服务器','服务器/工作站','ibm','6888',default,default),
(0,'商务双肩背包','笔记本配件','索尼','99',default,default);
SQL演练
1. SQL语句的强化
---------------------------------------------------
--------------- 此处用来巩固之前所学------------------
--------------- 不需要可以直接看后面------------------
---------------------------------------------------
-- 查看所有数据库
show databases;
-- 查看当前使用数据库
select database();
-- 查看创建数据库的语句
-- show create database ...
show create database jingdong;
-- 查看当前数据库中的所有数据表
show tables ;
-- 查看数据表的结构
-- desc 数据表的名字
desc table_name;
-- 删除某一个数据表
drop table table_name;
-- 查询数据goods所有内容
select * from goods;
---------------------------------------------------
--------------- 不需要前面巩固可以从这里开始----------
---------------------------------------------------
-- 查询goods中商品名称是“超极本”的
select * from goods where cate_name="超级本";
-- 查询goods中价格小于3000的
select * from goods where price < 3000;
-- 查询cate_name为'超极本'的商品名称、价格
select name,price from goods where cate_name="超级本";
select name as 商品名称,price as 商品价格 from goods where cate_name="超级本";
-- 显示商品的种类
-- 思考: 后面两个分组去重有什么区别
select cate_name from goods;
select distinct cate_name from goods;
-- select distinct cate_id from goods;
select cate_name from goods group by cate_name;
-- 注意此处其实是要和聚合函数结合使用才能体现其价值
select cate_name,group_concat(name) from goods group by cate_name;
-- 求所有电脑产品的平均价格，并且保留两位小数
select round(avg(price), 2) from goods;
select round(avg(price), 2) as avg_price from goods;
-- 显示每种商品的平均价格
select cate_name, avg(price) from goods group by cate_name;
select cate_name, avg(price) from jingdong.goods group by cate_name;
-- 查询每种商品中，平均价，最便宜，最贵，数量
select cate_name, avg(price), min(price), max(price), count(*), group_concat(name) from jingdong.goods group by cate_name;
-- 查询所有价格大于平均价格的商品，并且按照降序排列
-- 思路
select round(avg(price), 4) from goods;
select id, name, price from goods where price > 5570.5741;
select id, name, price from goods where price > (select round(avg(price), 4) from goods) order by price desc;
-- 查询每种类型电脑中最贵的电脑信息
select cate_name, max(price), group_concat(cate_name, " ", name), count(*) from goods group by cate_name;
--说明：进行分组的时候使用group by,前面的select查询的信息必须要有进行分组的字段依据.
-- select * from goods group by cate_name; --错误
--思路
select * from goods
inner join
(
select
cate_name,
min(price) as min_price,
max(price) as max_price,
avg(price) as avg_price,
count(*) from goods group by cate_name
) as goods_new_info
on goods.cate_name = goods_new_info.cate_name and goods.price = goods_new_info.max_price;
--左连接查询
select * from (select cate_name, max(price) as max_price from goods group by cate_name) as new_goods_info
left join goods on new_goods_info.cate_name = goods.cate_name and new_goods_info.max_price = goods.price;
select * from (select cate_name, max(price) as max_price from goods group by cate_name) as new_goods_info
right join goods on new_goods_info.cate_name = goods.cate_name and new_goods_info.max_price = goods.price;
2. 创建"商品分类"表
--一个表不方便管理
-- 十分注意：通过另一个表的字段来存储一个表的主键的时候，两个字段的数据类型必须相同
-- 创建goods_cates表并直接插入值
create table if not exists goods_cates(
id int unsigned primary key auto_increment not null,
name varchar(50) not null
);
-- 查询goods表中商品的种类
select cate_name as name from goods group by cate_name;
--将分组结果插入到goods_cates--为指定字段插入值
insert into goods_cates (name) select cate_name from goods group by cate_name;
select * from goods_cates;
3. 同步表数据
-- 同步表数据 通过goods_cate表来更新goods表 -- 十分注意：通过另一个表的字段来存储一个表的主键的时候，两个字段的数据类型必须相同 select * from goods as g inner join goods_cates as c on g.cate_name = c.name; -- 通过goos_cates数据表来更新goods表 update goods as g inner join goods_cates as c on g.cate_name = c.name set g.cate_name = c.id;4. 创建“商品品牌表”表
58到家数据库30条军规解读
-- 创建商品品牌数据表 先查询紧接着插入 注意name值要一样
create table goods_brands(
id int unsigned primary key not null auto_increment,
name varchar(40) not null)select brand_name as name from goods group by brand_name;
select * from goods_brands;
5. 同步数据
-- 同步数据 update goods as g inner join goods_brands as b on g.brand_name = b.name set g.brand_name = b.id;6. 修改表结构
-- 查看goods的数据表结构 desc goods; -- 修改表结构 :通过alter table修改表结构 -- g.brand_name与b.id字段的数据类型要一致 alter table goods change brand_name brand_id int unsigned not null; alter table goods change cate_name cate_id int unsigned not null; --change表示重命名改动 -- 可以同时修改多个字段 -- alter table goods -- change brand_name brand_id int unsigned not null, -- change cate_name cate_id int unsigned not null;7. 外键
-- 分别在good_cates 和 goods_brands表中插入记录
insert into goods_cates (name) values ('路由器'),('交换机'),('网卡');
insert into goods_brands (name) values ('海尔'),('清华同方'),('神州');
-- 在goods数据表中写入任意记录
-- insert into goods (name, cate_id, brand_name, price) values ('LasterJet Pro P1606dn 黑白激光打印机', 12, 4, '1489');
-- 查询所有商品的详细信息(通过内连接)
select g.id,g.name,c.name,b.name,g.price from goods as g
inner join goods_cates as c on g.cate_id=c.id
inner join goods_brands as b on g.brand_id=b.id;
-- 查询所有商品的详细信息(通过左连接)
select g.id,g.name,c.name,b.name,g.price from goods as g
left join goods_cates as c on g.cate_id=c.id
left join goods_brands as b on g.brand_id=b.id;
-- 设置外健
-- 给goods表cate_id 字段添加外健进行约束
alter table goods add foreign key (cate_id) references goods_cates(id);
alter table goods add foreign key (brand_id) references goods_brands(id);
外键取消
show create table goods; -- 在实际开发中很少使用外健 -- 外健的使用会极大降低数据库的更新的效率 -- 可以禁止使用外健 -- 真正开发过程中约束可以通过语法逻辑进行控制 -- 取消外健 -- 首先获取外键约束的名称 : 通过show create table goods;来获取 -- 然后通过获取的名称来删除外健 外健名称在show create table goods;生成的语句里面 alter table goods drop foreign key goods_ibfk_2; select * from goods as g left join goods_cates as c on g.cate_id=c.id left join goods_brands as b on g.brand_id=b.id; select g.*, c.name as cate_name, b.name as brand_name from goods as g left join goods_cates as c on g.cate_id=c.id left join goods_brands as b on g.brand_id=b.id order by price; select * from goods;外键：其实在设计定义数据库的时候，就已经确定了要不要使用外键：比如下面的逻辑。
-- 商品表
create table goods(
id int unsigned primary key auto_increment not null,
name varchar(150) not null,
cate_name varchar(40) not null,
brand_name varchar(50) not null,
price decimal(10,3) not null default 0,
is_show bit not null default 1,
is_saleoff bit not null default 0,
foreign key(cate_id) references goods_cates(id);
foreign key(brand_id) references goods_brands(id);
);
8. 其实就是多创建一个表，然后从原来的表上使用外键进行关联：下面代码可以一次性复制粘贴进行联系
-- 订单表
create table orders(
id int unsigned primary key auto_increment not null ,
order_data_time datetime not null ,
customers_id int unsigned not null
);
-- 设置外键
alter table orders add foreign key (customers_id) references customers(id);
-- 顾客表
create table customers(
id int unsigned primary key auto_increment not null ,
name varchar(150) not null ,
address varchar(150) not null ,
tel varchar(20) not null ,
passwd varchar(30) not null
);
-- 订单详情表
create table order_detail(
id int unsigned auto_increment primary key not null ,
quality int unsigned not null ,
order_id int unsigned not null ,
good_id int unsigned not null
);
alter table order_detail add foreign key (order_id) references orders(id);
alter table order_detail add foreign key (good_id) references goods(id);
desc orders;
desc goods;
# 第二部分：Python *** 作 MySQL
安装pymysql pip install pymysql
其实python当作MySQL客户端
1. 初尝python与mysql交互
from pymysql import *
# pymysql *** 作数据库流程：开始-创建connection-获取cursor-mysql语句-关闭cursor-关闭connection-结束
def main():
#创建connection连接 连接对象
conn = connect(host = "localhost", port = 3306, user = 'root', password = '123456', database = 'jingdong', charset = 'utf8')
#获取Cursor对象 游标对象
cs1 = conn.cursor()
count = cs1.execute('select id, name from goods where id > 4')
print("打印受影响的行数：", count)
# print(cs1.fetchall())
# print(cs1.fetchmany(2))
for i in range(count):
#获取查询的结果
result = cs1.fetchone() #返回一个元组 fetchmany()和fetchall()返回的结果是元组套元组
print(result)
cs1.close()
conn.close()
if __name__ == '__main__':
main()
2. pymysql查询数据库、面向对象
from pymysql import *
class JD(object):
def __init__(self):
# 创建connection连接 连接对象
self.conn = connect(host="localhost", port=3306, user='root', password='123456', database='jingdong', charset='utf8')
# 获取Cursor对象 游标对象
self.cursor = self.conn.cursor()
def __del__(self):
# 关闭cursor对象
self.cursor.close()
self.conn.close()
def execute_sql(self, sql):
self.cursor.execute(sql)
for temp in self.cursor.fetchall():
print(temp)
def show_all_items(self):
sql = "select * from goods;"
self.execute_sql(sql)
def show_cates(self):
sql = "select name from goods_cates;"
self.execute_sql(sql)
def show_brands(self):
sql = "select name from goods_brands;"
self.execute_sql(sql)
# @staticmethod #静态方法
def print_menu(self):
print("--------------------京东--------------------")
print("1:所有的商品")
print("2:所有的商品分类")
print("3:所有的商品品牌分类")
num = input("请输入对应功能序号:")
return num
def run(self):
while True:
num = self.print_menu() #实例方法可以调任何方法
if num == "1":
#调用所有商品
self.show_all_items()
elif num == "2":
self.show_cates()
elif num == "3":
self.show_brands()
else:
print("输入有误,请重新输入!")
# 面向对象的优点：能封装的尽量封装,调用者很简单,嵌套调方法也很容易,这些基本的方法放进一个基类中,通过类的继承，可以重新写一些新的方法。
def main():
#创建一个京东商城对象
jd = JD()
#调用这个对象的run方法
jd.run()
if __name__ == "__main__":
main()
3. pymysql添加数据库、面向对象
增删改涉及到数据库的变更,查询不改变数据库
pymysql中凡是涉及到数据库的增删改时,如果不输入commit,数据是不会插入表中,但是每次插入值之后（不提交）数据表的id字段(auto increament)还是增加的,通过show create table table名查看,目的是解决高并发
过程中的错误,实际应用中,数据库中值得插入属于高并发模式,哪个先抢到即先占领ID字段的值,防止后面多个插入进行提交之后造成的混乱错误.
-不管是增删改哪一种，只要commit之后数据开始生效.
如果数据插入错误,可以采用回滚rollback函数实现,前提是不提交,只要一提交数据就生效,注意的是如果进行增删改 *** 作,但是发现数据有误就不提交,且进行了rollback,如果再进行新的增删改 *** 作并
commit提交,因之前进行的错误增删改 *** 作而造成的id字段增长不会倒回去,只能在之前的基础上继续增长.
from pymysql import *
class JD(object):
def __init__(self):
# 创建connection连接 连接对象
self.conn = connect(host="localhost", port=3306, user='root', password='123456', database='jingdong', charset='utf8')
# 获取Cursor对象 游标对象
self.cursor = self.conn.cursor()
def __del__(self):
# 关闭cursor对象
self.cursor.close()
self.conn.close()
def execute_sql(self, sql):
self.cursor.execute(sql)
for temp in self.cursor.fetchall():
print(temp)
def show_all_items(self):
sql = "select * from goods;"
self.execute_sql(sql)
def show_cates(self):
sql = "select name from goods_cates;"
self.execute_sql(sql)
def show_brands(self):
sql = "select name from goods_brands;"
self.execute_sql(sql)
def add_brands(self):
item_name = input("输入新商品名称:")
# sql = """inseart into good_brand (name) values ("%s") % item_name"""
sql = "insert into goods_brands (name) values ('%s')" % item_name
self.cursor.execute(sql)
self.conn.commit() #确定提交
# self.conn.rollback() #回滚
@staticmethod #实例方法 不需要self
def print_menu():
print("--------------------京东--------------------")
print("1:所有的商品")
print("2:所有的商品分类")
print("3:所有的商品品牌分类")
print("4:添加商品品牌")
num = input("请输入对应功能序号:")
return num
def run(self):
while True:
num = self.print_menu()
if num == "1":
#调用所有商品
self.show_all_items()
elif num == "2":
self.show_cates()
elif num == "3":
self.show_brands()
elif num == "4":
self.add_brands()
else:
print("输入有误,请重新输入!")
# 面向对象的优点：能封装的尽量封装,调用者很简单,嵌套调方法也很容易,这些基本的方法放进一个基类中,通过类的继承，可以重新写一些新的方法。
def main():
#创建一个京东商城对象
jd = JD()
#调用这个对象的run方法
jd.run()
if __name__ == "__main__":
main()
4. 此处介绍SQL注入
# SQL注入
# 此处商品名称输入为:'or 1=1 or '1时即可打印出所有数据
# 'or 1=1 or'1或者 'or 1=1 or' 这里的两个单引号表示与'%s'的两个单引号进行配对 单引号双引号取决于input接受输入时的"%s"还是'%s' select * from goods where name = ''or 1=1 or'1';
# select * from goods where name = ""or 1=1 or "";
from pymysql import *
class JD(object):
def __init__(self):
# 创建connection连接 连接对象
self.conn = connect(host="localhost", port=3306, user='root', password='123456', database='jingdong', charset='utf8')
# 获取Cursor对象 游标对象
self.cursor = self.conn.cursor()
def __del__(self):
# 关闭cursor对象
self.cursor.close()
self.conn.close()
def execute_sql(self, sql):
self.cursor.execute(sql)
for temp in self.cursor.fetchall():
print(temp)
def show_all_items(self):
sql = "select * from goods;"
self.execute_sql(sql)
def show_cates(self):
sql = "select name from goods_cates;"
self.execute_sql(sql)
def show_brands(self):
sql = "select name from goods_brands;"
self.execute_sql(sql)
def add_cates(self):
cate_name = input("请输入商品名称:")
sql = "insert into goods_cates (name) values ('%s')" % cate_name
self.cursor.execute(sql)
self.conn.commit()
def add_brands(self):
item_name = input("输入新商品品牌名称:")
sql = "insert into goods_brands (name) values ('%s')" % item_name
self.cursor.execute(sql)
self.conn.commit() #确定提交
# self.conn.rollback() #回滚
def get_info_by_name(self):
find_name = input("请输入要查询的商品brand_id:")
sql = """select * from goods where brand_id = '%s';""" % find_name
print("——————————————>%s<-------------" % sql)
self.execute_sql(sql)
@staticmethod
def print_menu():
print("--------------------京东--------------------")
print("1:所有的商品")
print("2:所有的商品分类")
print("3:所有的商品品牌分类")
print("4:添加商品")
print("5:添加商品品牌")
print("6:根据名字查询一个商品")
num = input("请输入对应功能序号:")
return num
def run(self):
while True:
num = self.print_menu()
if num == "1":
#调用所有商品
self.show_all_items()
elif num == "2":
self.show_cates()
elif num == "3":
self.show_brands()
elif num == "4":
self.add_cates()
elif num == "5":
self.add_brands()
elif num == "6":
self.get_info_by_name()
else:
print("输入有误,请重新输入!")
def main():
#创建一个京东商城对象
jd = JD()
#调用这个对象的run方法
jd.run()
if __name__ == "__main__":
main()
5.防止SQL注入
from pymysql import *
class JD(object):
def __init__(self):
# 创建connection连接 连接对象
self.conn = connect(host="localhost", port=3306, user='root', password='123456', database='jingdong', charset='utf8')
# 获取Cursor对象 游标对象
self.cursor = self.conn.cursor()
def __del__(self):
# 关闭cursor对象
self.cursor.close()
self.conn.close()
def execute_sql(self, sql):
self.cursor.execute(sql)
for temp in self.cursor.fetchall():
print(temp)
def show_all_items(self):
sql = "select * from goods;"
self.execute_sql(sql)
def show_cates(self):
sql = "select name from goods_cates;"
self.execute_sql(sql)
def show_brands(self):
sql = "select name from goods_brands;"
self.execute_sql(sql)
def add_brands(self):
item_name = input("输入新商品名称:")
sql = "insert into goods_brands (name) values ('%s')" % item_name
self.cursor.execute(sql)
self.conn.commit() #确定提交
# self.conn.rollback() #回滚
def get_info_by_name(self):
find_name = input("请输入要查询的商品名称:")
# sql = """select * from goods where name = "%s"; """ % find_name
# print("——————————————>%s<-------------" % sql)
# self.execute_sql(sql)
sql = "select * from goods where name = %s;"
self.cursor.execute(sql, [find_name]) #防止SQL注入将输入值添加到一个字典中，让其完成配对 cursor.execute自动匹配find_name到sql中%s
print(self.cursor.fetchall())
@staticmethod
def print_menu():
print("--------------------京东--------------------")
print("1:所有的商品")
print("2:所有的商品分类")
print("3:所有的商品品牌分类")
print("4:添加商品品牌")
print("5:根据名字查询一个商品")
num = input("请输入对应功能序号:")
return num
def run(self):
while True:
num = self.print_menu()
if num == "1":
#调用所有商品
self.show_all_items()
elif num == "2":
self.show_cates()
elif num == "3":
self.show_brands()
elif num == "4":
self.add_brands()
elif num == "5":
self.get_info_by_name()
else:
print("输入有误,请重新输入!")
def main():
#创建一个京东商城对象
jd = JD()
#调用这个对象的run方法
jd.run()
if __name__ == "__main__":
main()
# 第三部分：MySQL高级
1. 视图
1.问题
······
6. 删除视图
drop view 视图名称; eg: drop view v_goods_info;7. 视图demo
select *from goods as g left join goods_cates as c on g.cate_id=c.id left join goods_brands as b on g.brand_id=b.id;
select g.*,c.name as cate_name,b.name as brand_name from goods as g left join goods_cates as c on g.cate_id=c.id left join goods_brands as b on g.brand_id=b.id;
create view v_goods_info as select g.*,c.name as cate_name,b.name as brand_name from goods as g left join goods_cates as c on g.cate_id=c.id left join goods_brands as b on g.brand_id=b.id; show tables;
select *from v_goods_info; select *from v_goods_info limit 5;
注意，虚表只能用来查找，不能修改，如下：
- 提高了重用性，就像一个函数对数据库重构却不影响程序的运行提高了安全性能，可以对不同的用户让数据更加清晰
个人理解，虚表只是存储了一个链接，自动加载，要修改内容还是要修改实际存在的内容，就是原来的表怎么修改就怎么修改，修改完之后，虚表自动变化。
事务这里可以分为提交和回滚：就是提交失败，你就回滚回去。
# 所谓事务，即一个 *** 作序列,即这些 *** 作要么都执行 要么都不执行 是一个不可分割的工作单元. # 开启事务 begin; # 或者 start transaction # python中默认已经开启了事务,必须commit之后数据才可以提交 # mysql命令行工具执行完语句之后自动进行了commit,但是一旦开启了事务,不提交,数据就不会写入数据库,同时该条记录处于上锁状态,其他用户此时对这条记录进行 *** 作的话会处于等待状态, # 必须进行提交之后另一个用户才可以对此字段进行 *** 作,这也是隔离性的体现,保证数据的安全. # 原子性:保证了 *** 作要么成功,要么不成功. # 一致性:保证了数据在commit之前不会因为系统等其他外部因素造成数据错误 # 隔离性:一个SQL语句的执行不会影响另一个SQL语句的执行. # 持久性:一旦事务提交,则会永久保存在数据库中.3. 索引
# 索引是一种特殊的文件(InnoDB数据表上的索引是表空间的一个重要组成部分),它们包含着对数据表里所有记录的引用指针.加快数据库的查询速度 create table test_index(title varchar(10)); ######################################################## # 接下来，插入10万条数据到test_index.py(代码见后面) ######################################################## select count(*) from test_index; # 开始运行时间监测 set profiling = 1; select * from test_index where title = 'haha-99999'; # 查看执行时间 show profiles; # 为表test_index的title字段创建索引title_index create index title_index on test_index(title(10)); # 执行查询语句 select * from test_index where title = 'haha-99999'; show profiles; #查看索引 show index from test_index; show index from goods; # 创建索引 # 如果指定字段是字符串 需要指定长度 建议长度和创建字段的数据长度一致 # 字段类型如果不是字符串 可以不填写长度 # create index 索引名称 on 表名(字段名称(长度)) # 删除索引 # drop index 索引名称 on 表名;
########################################################
# 插入10万条数据到test_index.py
########################################################
from pymysql import connect
def main():
#创建connection连接 连接对象
conn = connect(host = "localhost", port = 3306, user = 'root', password = '123456', database = 'jingdong', charset = 'utf8')
#获取Cursor对象 游标对象
cs1 = conn.cursor()
for i in range(100000):
count = cs1.execute("insert into test_index values ('haha-%d')" % i)
conn.commit()
cs1.close()
conn.close()
if __name__ == '__main__':
main()
4. 账户管理
MySQL用户管理：添加用户、授权、删除用户
https://www.bilibili.com/video/av56919275?p=36
后记数据库就是一个底层存储系统，可以很好的理解对磁盘的01 *** 作的封装。小王：给别人做东西，要不要一步到位；慢慢体会,哈哈哈！！！索引，就是为了追求效率，就是用C语言写的。
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）