MYSQL数据库应用详解

常用工具

window : mysql workbench、 navicat、sqlyog、heidisql、mysql front

linux : mysql workbeanch 、navicat

linux : mysql workbeanch 、navicat

架构演变

架构1.0 - 单机单库

数据量太大、超过一台服务器承受范围

读写操作量大，超出一台服务器承受

一台服务器挂了，应用也会挂掉（可用性差

架构 2.0 - 主从架构
读写分离

保证服务的可用

数据量太大超过一台服务器

写操作太大超出一台服务器的性能

架构 3.0 - 分库分表
写操作太大超出一台服务器的性能

数据如何路由是一个关键问题，一般采用范围拆分，list拆分，hash拆分

如何保持数据一致性是一个难题

架构 4.0 - 云数据库
使用Saas服务，服务提供商负责解决可配置性，可扩展性，多用户存储接哦古涉及等难点问题

SQL基本使用

SQL约束

约束	约束表达式	备注
主键	primary key
非空	not null
唯一	unique
默认	default
外键	foreign key

常用关键字

关键字	含义	备注
distinct	去除重复项
like	模糊查询（% 任意多个字符， _ 一个任意字符）
in	非连续范围内
between … and …	一个连续的范围内
count(*)	统计总行数
max()	求最大值
min()	求最小值
sum(列)	求和
avg(列)	求平均数
group by	将查询结果按照1个或者多个字段进行分组，字段值相同的一组
group by + having	分组后查询指定条件输出的查询结果
having	只能用于group by
order by	排序（asc升序 desc降序）

SQL 增删改查

# 连接数据库
mysql -u"用户名" -p
$pwd# 数据库退出
quit# 查看数据库
show databases;# 查看数据库版本
select version()# 显示时间
select now();# 创建数据
create database `python01` charset="utf-8";# 展示数据库创建语句
show create database "database03"# 查看当前使用数据库
select database();# 使用数据库
use "数据库名称";# 删除数据库
drop database "数据库名称";# **数据库表的操作**
# 查看当前数据库中所有表
show tables;# 创建表
# auto_increment表示自动增长
# not null 表示不能为空
# primary key 表示主键
# create table 数据库名称（字段 类型 约束 [字段 类型 约束]);
create table demo(id int,name varchar(20));# 查看表结构
desc "表名";# 创建 students 表（id、name、age、high、gender、cls_id）
create table students(id int not null primary key auto_increment,name varchar(30),age tinyint unsigned default 0,high decimal(5,2),gender enum('男','女','中性','保密') default '保密',cls_id int unsigned);# 表中插入数据
insert into student values(0,"老王",18,175.88,"男",1);
select * from student;# 查看表的创建语句
show create table students# 修改表 - 添加字段
# alter table 表名 add 列名 类型；
alter table students add birthday datetime;# 修改表- 修改字段 ： 不重名命名 - 修改字段类型 + 约束
# alter table 表名 modify 列名 类型及约束
alter table students modify birthday date dafault '1997-01-01'# 修改表- 修改字段 ： 重名命名 - 改变字段的名称
# alter table 表名 change 原名 新名 类型及约束；
alter table students change birthday birth date dafault '1997-01-01'# 修改表 - 删除字段
# alter table 表名 drop 列名；
alter table students drop high;# 删除表
drop table "表名";
drop database "数据库";
drop table "数据表";**# 新增**# 全列插入   insert [into] 表名 values(...)
# 主键字段 - 可以用 0 null default 来占位
# 向 classes 表中插入一个班级
insert into class values(0,"python")   # 0 是 id位置 用 0 表示自增 # 枚举类型的插入 1-男   2-女
insert into students values(0,'tony',18,1,1,'1997/01/01');# 部分插入
# insert into 表名(列1，...) values(值1，...)
insert into students(name,gender) values("小乔",2);# 多行插入
insert into students(name,gender) values("小乔",2)("周瑜",1)("孙策",1);**#修改**
# update 表名 set 列1=值1，列2=值2...where 条件；
update students set age=18;   # 全表修改
update students set age=28 where name = "tony";   # 条件筛选修改# 物理删除
# delete from 表名 where 条件
delete from students where name = 'tony';# 逻辑删除 - 用一个字段表示此条数据已经不能在再用  例如 ：is_delete字段
alter table students add is_delete int default 0 ;
updata students set is_delete = 1 where id = 6；**# 基本查询**
# select 去重选项 字段列表[as 字段名] from 数据表 where [group by 子句] [having 子句] [order by 子句 ] [order by 子句] [limit子句];
# 查询全部
select * from students;
# 去除重复字段查询
select distinct name from students;
# 查询指定列
select id,name from students;
# 可以使用 as 为列或表指定别名
select id, cls_id as "班级" from students;
select student.name as "姓名" from students;#数据库数据查询# 从 第10行开始获取20行数据，
# 分页（从start开始，获取count条数据）
select * from students limit 10,20; # join查询连接查询
select * from table1 inner join table2 on table1.firstid = table2.secondid;
select * from table1 left join table2 on table1.firstid = table2.secondid;
select * from table1 right join table2 on table1.firstid = table2.secondid;# 子查询
select * from students where height = (select max(height) from students);# 创建数据表
create table student(sid int(4) not null primary key,sname varchar(36),gid int(4) not null);
# 添加外键
alter table tablesname add constraint prinaryname foreign key(id) references table2(idname)
# 删除外键
alter table tablename1 drop foreign key prinaryname1;**# 比较运算符**
>    # 大于
<    # 小于
>=  #大于等于
<=  #小于等于
!= / <>  # 不等于**# 逻辑运算符**
and # 和
or  # 或者
not # 非/取反**# 模糊查询**
# like
# %  替换1个或者多个
# _ 替换1个# 查询姓名中 以 "李" 开始的名字
select * from students where name like '李%';
# 查询姓名中 带有 "李" 开始的名字
select * from students where name like '%李%';
# 查询有2个字的名字
select * from students where name like '__';
# 查询至少有2个字的名字
select * from students where name like '__%';# where 子句（条件）范围查询
# in 表示在一个非连续的范围内
select * from students where id in(1,3,8);
select * from students where id not in(1,3,8);# between...and... 表示在一个连续的范围内
select * from students where id between 3 and 8;
# id 3-8 男生
select * from students where id between 3 and 8 and gender=1;
select * from students where id not between 3 and 8 and gender=1;# 判断为空 is null
# 非空  is not null
# 查询 cls_id 为空的数据
select * from students where cls_is is null;**# 聚合函数**
# 总数  count()
# 查询学生总数
select cout(*) from students;
# 查询男性有多少人
select cout(*) as "男性人数" from students where gender = 1;# 最大值/最小值  max / min
select max(age) from students;
# 查询男性 ID的最大值
select max(id) from students where gender=1;
# 查询女性的最高身高
select max(height) from students where gender = 2;# 求和 sum（）
# 查询男生的年龄和
select sum(age) from students where gender =1;# 平均值 avg()  默认保留4位
# 查询未删除女生的ID的平均值
select avg(id) from students where gender=2 and is_delete=0;# 四舍五入 round(123.23,1) 保留 1 位小数
# 计算所以人的平均年龄，保留2位小数
select round(ave(age),2) from students;# 分组 group by
# 按照性别分组，查询所有的性别
select gender from students group by gender;# 计算男生和女生的人数
select gender as "性别"，count(*) from students where gender = 1;
select gender as "性别"，count(*) from students where gender = 2;select gender as "性别"，count(*) from students group by gender;# 男女同学最大年龄
select gender as "性别"，max(age) from students group by gender；# group_concat() 查看组内信息 （ 把所有内容写在同一个格子里）
# 查询同种性别中的姓名
select gender as "性别"，max(age),group_concat(name) from students group by gender;
# 查询组内年龄，姓名(name + age) 写在同一框格中
select gender as "性别",group_concat(name,age) as "组内姓名" from students group by gender;# having  分组之后的筛选
# 查询男生女生总数大于2s
select gender as "性别",count(*) from students group by gender having count(*) > 2;
# 查询男生 女生 总数大于 2 的姓名
select count(*),group_concat(name) from students group by gender having count(*) > 2;
# 查询平均年龄超过18岁的性别，以及姓名 having age(age) > 18
select gender,group_concat(name),avg(age) from studernt group by gender having avg(age) > 18;# 数据库排序 order by / asc 从小到大排列，即升序，默认 / desc 降序
# 查询年龄在 18-26 岁之间的男同学 ，按照年龄从小到大排序
select * from students where age between 18 and 26 group by gender having gender =1 order by age;
select * from students where age between 18 and 26 and gender =1 order by age;# 查询年龄在 18-34 岁之间的女同学，身高从高到矮排序
select * from students where age bewteen 18 and 34 and gender =2 order by height desc;# order by 多个字段
# 查询年龄在18-28之间，女性，身高从高到矮，如果身高相同 按年龄从小到大排列
select * from students where age bewteen 18 and 28 and gender = 2 order by height descc,age asc;
# 按年龄从小到大，身高从高到矮
select * from students order by age asc,height desc;# 分页 limint start count
# 限制查询出来的结果
select * from students limit 2;     # 查询前两条数据
select * from students limit(3,5);   # 从3位置开始 查询5条数据# 数据库的连接查询
inner join ...on  # 内连接
select * from students inner join classes on students.cls_id = class.id;
# 按照要求显示姓名、班级
select students.name,classed.name from students inner join classes on students.cls_id = class.od;
left join ...on  # 左连接
light join ...on  # 右连接**# 子查询**
# 查询最高的男生的信息
select * from students where height = (select max(height) from students where gender =1 );
# 查询高于平均身高的信息
select * from students where height > (selecct avg(height) from students);# 自关联 - 省市区三级联动
select * from provinces as p inner join cities as c on p.'provinceid' = c.'provineid' having p.province ="吉林省"

视图增删改查

# 视图创建
create view v_stu_score as (select * from table1);
# 视图查看（查看表时会显示所有视图）
show tables;
# 使用视图(（v_stu_score 视图名）)
select * from v_stu_score;
# 删除视图
drop view v_stu_sco;

SQL 索引

定义：索引是一种特殊的文件(InnoDB 数据表上的索引是表空间的一个组成部分)，包含着对数据表里所有记录的引用指针

效率：300 万左右数据量，可以提高一倍的查询效率

索引建立：
主键自动建立索引

频繁作为查询条件的字段因该建立索引

查询中与其他表关联的字段，外键关系建立索引

在高并发的情况下创建复合索引

查询中排序的字段、排序字段若通过索引去访问大大提升排序速度（建立索引的顺序跟排序的顺序保持一致）

# 查看索引
show index from "表名"；
# 创建索引
create [unique] index "索引名称" on "表名（字段名称（长度））"
create index idx_name on students(name(30));  # 单值索引
# 删除索引
drop index "索引名称" on "表名";

SQL 事务

事务：就是一系列的操作，一旦出现问题则进行回滚

#事务开启
begin "或" start transaction
# 事务提交
commit;
# 回滚事务
rollback;

SQL 权限控制

# 查看user表结构
desc user;
# 查看所有用户
select host,user,authentication_string from user;
# 创建账号& 授权
grant 权限列表 on 数据库 to '用户名'@'访问主机' identified by '密码';
# 退出root登陆
quit

存储引擎

存储引擎 Innodb : 最大程度的支持并发

使用表空间进行数据存储（on/off）

系统表空间会产生I/O瓶颈，刷新数据的时候是顺序进行的，所以会产生 I/O 瓶颈，独立空间可以同时向多个文件刷新数据

支持外键、支持事务、行级锁最大程度支持并发，缓存索引、缓存真实数据、表空间大
```
# 查看存储引擎
show engines;
show variables like 'innodb_file_per_table' # 查看是否独立表空间
set global innodb_file_per_table = off    # 关闭独立表空间
```
存储引擎 MyISAM ：适合非事务应用，只读类应用

支持表数据压缩（linux），压缩后只能读，不能写

不支持外键，不支持事务

表级锁，不适合高并发

只缓存索引，不缓存真实数据

表空间较小
```
myisampack -b -f myIsam.MYI
# 表损坏修复
reapir table "表名";
```
存储引擎 CSV : 文本存储表的内容

.CSM 文件存储表的元数据，如表的状态、数据量等

.frm 文件存储表结构信息

适合做数据交换的中间表

不支持主键，不支持自增长，所有列不能为空
存储引擎 Memory ：内存型

支持 hash（用于等值查找）、btree索引（范围查找）

所有字段长度固定

不支持 BLOB 和 text 等大字段

使用表级锁

重启后数据会小时

服务架构说明

网络链路层

能够与mysql服务器建立链接的客户端（java、C、python、.net）

服务层（msyql server）
包含系统管理和控制工具、链接池、SQL接口、解析器、查询优化器、缓存

链接池：负责存储和管理客户端的数据路链接，一个线程负责管理链接

系统管理和控制工具：备份恢复、安全管理、集群管理

SQL接口：接口客户端发送过来的sql命令，并返回查询结果。

解析器：负责将请求的 SQL 解析生成一个解析树，然后根据mysql规则进行检查树是否合法。

查询优化器：当解析树通过解析器语法检查后，交给优化器及逆行转化成执行计划，然后与存储引擎交互

缓存：小缓存组成（表缓存、记录缓存、权限缓存、引擎缓存）、如果查询缓存名中，则执行查询缓存

引擎层
存储引擎层：负责数据的存储和提取

系统文件层
负责数据库的数据和日志存储在文件系统中，并完成与存储引擎的交互

日志文件、数据文件、配置文件、pid文件、socket文件

日志文件
error log 日志：错误日志 ( show variables like %log_err%)

慢查询日志：记录一般查询语句 ( show variables like %general% )

二进制日志（binary log）：记录对数据库的执行更改记录语句发生时间，执行时长，用于数据库恢复和主从复制。( show binary logs )

慢查询日志（Slow query log）

配置文件
用于存放 mysql所有配置信息文件、比如my.cnf、my.ini等

数据文件
db.opt 文件：记录这个库默认使用的字符集和校验规则

frm 文件：存储与相关的元数据信息，包括表结构的定义信息，每一张表都会有一个frm文件

MYD文件：MySAM存储引擎专用，存放MySAM表的数据，每一张表都会有一个 .myd文件

MYI文件：MySAM存储引擎专用，存放MySAM表的索引相关的信息，每一张表都会有一个 .myi文件

ibd 文件和IBDATA文件：存放InnoDB的数据文件（包括引擎）。InnoDB存储引擎有两种表空间方式：独立表空间，共享表空间独享表空间使用.ibd文件夹存放数据，且每一张InnoDB表对应一个.ibd表对应一个 .ibd文件。共享表空间使用.ibdata文件，所有表共享使用一个（或多个、自行设置）.ibdata文件

ibdata1 文件：系统表空间数据文件，存储表元数据，Undo日志等

ib_logfile0、ib_logfile1文件、Redo log日志文件

pid文件：进程文件，存放自己的进程id

socket文件：客户端可用不通过TCP/IP 网络而直接使用socket链接数据库

日志说明

undo log

数据库事务开始前，将要需修改的记录存放在Undo日志里，当事务回滚时，数据崩溃时，可以利用Undo日志，撤销未提交事务对数据库产生影响

Undo Log 产生和销毁： Undo Log在事务开始前产生，事务在提交时，并不会立刻删除undo log , innodb会将该事务对那个的undo log放入到删除列表中，后面会通过后台线程 purge thread进行回收处理。Undo Log 属于逻辑日志，记录一个变化过程，发生一个动作会记录一个相反的 updata

Undo Log 存储：采用段的方式进行管理和记录

Redo Log

以恢复操作为目的，在数据库发生意外时重新操作

在事务中修改任何数据，将最新的数据备份存储的位置

随着事务操作执行，就会生成，在事务提交时会产生写入Log Buffer,而不是将事务提交立刻写入磁盘文件

随着事务的提交就立刻写入磁盘文件

Redo log工作原理

实现事物的持久性而出现的产物。防止发生故障时，尚有脏页没有写入到 IBD文件中，重启mysql服务时，根据Redo log 进行重做，从而达到事物未吸入磁盘数据的持久化特性
写入机制：以顺序循环的方式写入文件，写满是则回溯到第一个文件，进行覆盖写
redo log 相关配置参数：show variables like ‘%innodb_log%’；

Bin log 日志

redo log 属于 innodb引擎所特有的日志，而 mysql server也有自己的日志，叫做binary log(二进制文件) 简称 bin log

记录数据表结构变更及表数据修改的二进制日志

以事件形式记录，包含语句所执行的消耗时间

应用场景：主从同步（开启 bin log，传递给从库）、数据恢复

文件记录模式 row模式（对每一行进行记录，批量操作是日志量巨大）

statment 模式（每条记录的sql都会就在master的 binlog中，在sql中含有变量时，比如last inset id 等时，不可靠）

mixed 模式（正常用sql，识别用 row模式）

# binlog 状态查询（开启状态）
show variables like 'log_bin';# 开启bin log 文件 需要修改 my.cnf 或my.ini配置文件，在增加 log_bin = mysql_bin_log，重启mysql服务
# log-bin = ON
# log-bin-basename=mysqlbinlog
binlog-format=ROW
log-bin = mysqlbinlog# 使用show binlog events命令
show binary logs； // 展示 bin log 文件
show master status； // 现在使用的 bin log文件
show binlog events； // 包含哪些事件
show binlog events in ‘mysqlbinlog.000001’;# 系统cmd下查看 binlog文件
mysqlbinlog “文件名”
mysqlbinlog “文件名” > 'test.sql'# 使用 binlog恢复数据
# 按指定时间恢复
mysqlbinlog -- start -datetime =  -- stop-datetime=“2020-11-10 18:00:00” mysqlbinlog.00002 | mysql -uroot -p1234
# 按事件位置号恢复
mysqlbinlog -- start -position=154  stop-position=957 mysqlbinlog.00002 | mysql -uroot -p1234# 删除binlog文件
purge binary logs to 'mysqlbinlog.00001';  // 删除指定文件
purge binary logs before '2020-11-10 18:00:00'; //删除指定时间之前的文件
reset master; // 清除所有文件

MYSQL主从配置

master 将改变记录到二进制日志。这些记录过程叫做二进制日志事件，binary log events.

slave 将 master 的binary log events 拷贝到它的中继日志

slave 重做中继器日志中的事件，将改变应用到自己的数据库中，mysql复制是异步的且串行

# 主机配置文件 - my.ini
# 开启二进制日志
# log-bin = 自己本地的路径/mydqlbin
log-bin = mysql-bin
# 指定主服务器ID
server-id =1
# 需要从新启动服务# 从机配置文件 - mysqld.cnf
server-id = 2  # 不要和主服务器ID重复
log-bin = /自己本地的路径/mysql-bin.log
service mysql restart  # 重启服务# MySQL8.0主从配置 对从机进行授权
# 192.168.0.183 为从机IP
# 用户名 repl    密码 ： 123
CREATE USER 'repl'@'192.168.0.183' IDENTIFIED WITH mysql_native_password BY '123';
GRANT REPLICATION SLAVE ON *.* TO 'repl'@'192.168.0.183';show master status;
# 展示 ：( file:mysql-bin.000004   Position : 680 )# 对从机进行配置
# 主机IP地址
change master to master_host = '192.168.0.161',
# 主机用户名
master_user = 'juran',
# 密码
master_password = '123',
master_log_file = 'binlog.000004',
master_log_pos= 908;

数据库的分区

定义：根据某个区间值，特定值或 hash函数执行数据的聚合，让那个数据根据规则分布在不同的分区中

类型：Range分区、List分区、Hash分区

注意事项：避免跨分区查询、最好在where从句中包含分区值，具有唯一索引的表，主键或唯一索引必须是分区键的一部分

partition    # 分区
# 查看数据库支持项
show plugins;# 数据库分区特点
# 逻辑上为一个表，在物理上存储在多个文件中
create table `login_log`(login_id int(10) unsigned not null comment '登录用户id',login_time timestamp not null default current_timestamp,login_ip int(10) unsigned not null comment '登录ip')engine=innodb default charset=utf8 partition by hash(login_id) partitions 4;   # 将这个表划分4个分区# 删除分区(表中的数据也会删除)
alter table login_log_list drop partition p0;# 分区的数据迁移(p1分区数据迁移到table arch_login_log_list )alter table login_log_list exchange partition p1 with table arch_login_log_list;

Range分区

根据键值的范围，将数据存储到表的不同分区中

分区需要连续，但是不能重叠，分区不包含上限值，包含下限值

常用分区日期，时间，可以定期按分区记性清理历史数据

# 建立Range分区
create table `login_log_range`(login_id int(10) unsigned not null comment '登录用户ID',login_time timestamp not null default CURRENT_TIMESTAMP,login_ip int(10) unsigned not null comment '登录ip')engine=innodbpartition by range(login_id)(partition p0 values less than(10000), # 实际范围0-9999partition p1 values less than(20000), # 实际范围10000-19999partition p2 values less than(30000),partition p3 values less than maxvalue # 存储大于30000的数据
);

Hash 分区

根据 mod （分区键、分区值）把数据行存储到表的而不同分区内

数据可以平均分布在各个分区

Hash分区的键值必须是 INT 类型的值，或者通过函数可以转化为 INT类型

# 建立Hash分区表
create table `login_log`(login_id int(10) unsigned not null comment '登录用户ID',login_time timestamp not null default CURRENT_TIMESTAMP,login_ip int(10) unsigned not null comment '登录ip')engine=innodb default charset=utf8 partition by hash(login_id) partitions 4;# 时间类型用函数转化为整数
create table `login_log`(login_id int(10) unsigned not null comment '登录用户ID',login_time timestamp not null default CURRENT_TIMESTAMP,login_ip int(10) unsigned not null comment '登录ip')engine=innodb default charset=utf8 partition by hash(UNIX_TIMESTAMP(login_time))partitions 4;

List 分区

按分区键值取值的列表进行分区

同范围分区一样，各分区的列表值不能重复

每一行数据必须能找到对应的分区列表，否则数据插入失败

create table `login_log_list`(login_id int(10) unsigned not null comment '登录用户ID',login_time timestamp not null default CURRENT_TIMESTAMP,login_ip int(10) unsigned not null comment '登录ip',login_type int(10) not null)engine=innodbpartition by list(login_type)(partition p0 values in(1,3,5,7,9),partition p1 values in(2,4,6,8));

交互框架

Pymysql

import pymysql
pymysql.connect()   # 此对象为pymysql连接数据库的类# 创建Connection连接对象实例
conn = connect(host='localhost', port=3306, user='root', password='mysql', database='python1', charset='utf8')
# 创建游标
cursor = conn.cursor()
# 数据查询
sql = "select id,name from students where id = 7"
# 数据更新
sql = 'update students set name="刘邦" where id=6'
# 数据删除
sql = 'delete from students where id=6'
# 载入查询语句, 返回的是执行成功的条数，可以用于判断是否执行成功
cursor.execute(sql)
# 接收查询结果、就要一条
result = cursor.fetchone()
# 关闭游标
cursor.close()
# 关闭连接
conn.close() # 数据更新/或数据新增时
conn.commit()   # 提交
# 事务的回滚
conn.rollback()# 查看所有数据
cursor.fetchall()
cursor.fetchone()
cursor.fetchmany(2)

SQLAlchemy

框架定义：一个数据库 ORM框架

原生开发模式

from sqlalchemy import create_engine   # 引擎# 连接数据库
HOSTNAME = '127.0.0.1'    # IP
PORT = '3306'            # 端口
DATABASE = 'demo0417'    # 数据库名称
USERNAME = 'root'        # 用户名
PASSWORD = 'root'        # 密码# 驱动 方式 1  —  用 pymysql 连接
DB_URI = 'mysql+pymysql://{}:{}@{}:{}/{}'.format(USERNAME,PASSWORD,HOSTNAME,PORT,DATABASE)# 驱动 方式 2  —  用 mysqlconnector 连接
pip install mysqlconnector
DB_URI = 'mysql+mysqlconnector://{}:{}@{}:{}/{}'.format(USERNAME,PASSWORD,HOSTNAME,PORT,DATABASE)# 创建数据库引擎
engine = create_engine(DB_URI)# 创建连接
with engine.connect() as conn:# 执行SQL语句，原生的SQL写法result = conn.execute("select * from users")print(result.fetchone())  # 一条数据,返回一个元组print(result.fetchall())  # 多条数据

SQLAlchemy 常用数据类型

Integer  # 整形。
Float   # 浮点类型。
Boolean # 传递True/False进去。
DECIMAL # 定点类型。
enum    # 枚举类型。
Date    # 传递datetime.date()进去。
DateTime    # 传递datetime.datetime()进去。
Time    # 传递datetime.time()进去。
String  # 字符类型，使⽤时需要指定⻓度，区别于Text类型。
Text    # ⽂本类型。
LONGTEXT    # ⻓⽂本类型。

Column常⽤参数

default  # 默认值。
nullable    # 是否可空。
primary_key # 是否为主键。
unique  # 是否唯⼀。
autoincrement   # 是否⾃动增⻓。
sqlalchemy  # 常⽤数据类型
Column  # 常⽤参数
onupdate    # 更新的时候执⾏的函数。
name    # 该属性在数据库中的字段映射

ORM 框架使用

通过类的方式进行操作数据库，底层转化为 select 原生语句

"""
class Users(object):    name = "lcl"passuser = Users(1,"lcl")
user.add()类 ：class   一张表
属性 ：name   表字段
对象 ： 一条记录
"""
from sqlalchemy import create_engine
# 导入ORM的类
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column,Integer，StringHOSTNAME = '127.0.0.1'    # IP
PORT = '3306'            # 端口
DATABASE = 'demo0417'    # 数据库名称
USERNAME = 'root'        # 用户名
PASSWORD = 'root'        # 密码DB_URI = 'mysql+mysqlconnector://{}:{}@{}:{}/{}'.format(USERNAME,PASSWORD,HOSTNAME,PORT,DATABASE)engine = create_engine(DB_URI)# 实例化ORM的类 所有模型 继承自 declarative_base
Base = declarative_base(engine)# 使用 ORM 操作数据库, 继承 Base = declarative_base(engine) 的基类
class Students(Base):# 定义表的名字__tablename = "students"# 创建一些字段 通过 Column 进行创建id = Column(Interger, primary_key = True,autoincrement = True)   # 数据类型、主键、自增name = Column(String(50),nullable = False )   # 字符串类型、不能为空gender = Column(Interger,default = 1 ,comment = "1 为 男，2为女") # 模型映射到数据库中
Base.metadata.create_all()

ORM 增删改查

from sqlalchemy import create_engine
from sqlalchemy.declarative import declarative_base
from sqlalchemy import Column,Integer，String
from sqlalchemy.orm import sessionmakerHOSTNAME = '127.0.0.1'    # IP
PORT = '3306'            # 端口
DATABASE = 'demo0417'    # 数据库名称
USERNAME = 'root'        # 用户名
PASSWORD = 'root'        # 密码DB_URI = 'mysql+mysqlconnector://{}:{}@{}:{}/{}'.format(USERNAME,PASSWORD,HOSTNAME,PORT,DATABASE)
engine = create_engine(DB_URI)
Base = declarative_base(engine)class Article(Base):# 定义表的名字__tablename = "article"# 创建一些字段 通过 Column 进行创建id = Column(Interger, primary_key = True,autoincrement = True)   # 数据类型、主键、自增name = Column(String(50),nullable = False )   # 字符串类型、不能为空# 模型映射到数据库中
Base.metadata.create_all()
# 数据在内存中
article = Article(name = 'lcl')
# 将数据保存到数据库中
# 实例化 sessionmaker 类
# 类的实例化   __call__ 将类变成方法 去 调用
Session = sessionmaker( bind = engine )
session = Session()
# 数据添加 - 数据尚未提交
session.add(article)
# 数据提交
session.commit()print(article.name)
print(article.id)# 一次添加多条数据
session.add_all([article,article1])
session.commit()

ORM 增删改查-方法封装

from sqlalchemy import create_engine
from sqlalchemy.declarative import declarative_base
from sqlalchemy import Column,Integer，String
from sqlalchemy.orm import sessionmakerHOSTNAME = '127.0.0.1'    # IP
PORT = '3306'            # 端口
DATABASE = 'demo0417'    # 数据库名称
USERNAME = 'root'        # 用户名
PASSWORD = 'root'        # 密码DB_URI = 'mysql+mysqlconnector://{}:{}@{}:{}/{}'.format(USERNAME,PASSWORD,HOSTNAME,PORT,DATABASE)
engine = create_engine(DB_URI)
Base = declarative_base(engine)class Article(Base):__tablename__ = 'art'id = Column(Integer, primary_key=True, autoincrement=True)title = Column(String(50), nullable=False)content = Column(String(50))author = Column(String(50))def __str__(self):   return "Article(title:{},content:{},author:{})".format(self.title, self.content, self.author)# 模型映射到数据库中
Base.metadata.create_all()# 写入数据
def add_data():article = Article(title='Python', content='人生苦短,我用Python', author='龟叔')session.add(article)session.commit()# 数据的查询
def search_data():data = session.query(Article).all()      # all 查询所有for item in data:print(item)print(item.title)print(item.content)# print(data)# 条件 filter 方法 1  返回的是列表data = session.query(Article).filter(Article.title=='Python').all()for item in data:print(item)# filter_by 方法  返回的是列表data = session.query(Article).filter_by(title='JAVA').all()for item in data:print(item)print(data)# 查询第一条data = session.query(Article).first()print(data)# get 方法 传的ID 不存在 返回Nonedata = session.query(Article).get(1)   # 查询 ID 为 1 data = session.query(Article).get(2)   # 查询 ID 为 2 print(data)# ORM 修改
def update_data():# 查询出要修改的这条记录article = session.query(Article).first()article.title = 'lgcoder'print(article.title)# session.rollback()   回滚# print(article.title)session.commit()# ORM 删除
def delete_data():# 查询出要修改的这条记录article = session.query(Article).first()# 误操作# is_delete 1 未删除  0 删除# 修改操作  is_delete 1=>0session.delete(article)session.commit()

query 可用参数

"""
1.  模型对象。指定查找这个模型中所有的对象。
2.  模型中的属性。可以指定只查找某个模型的其中⼏个属性。
3.  聚合函数。
func.count：统计⾏的数量。
func.avg：求平均值。
func.max：求最⼤值。
func.min：求最⼩值。
func.sum：求和
"""
from sqlalchemy import function# 总条数
result = session.query(func.count(Article.id)).first()
# 求平均值
result = session.query(func.avg(Article.price)).first()

过滤条件

# 这些过滤条件都是只能通过filter⽅法实现的#  等于 equals
query.filter(User.name == 'ed').all()
# 不等于 not equals
query.filter(User.name != 'ed')
# 模糊查询 like
query.filter(User.name.like('%ed%'))
# 在...中 in
query.filter(User.name.in_(['ed','wendy','jack']))
# 同时，in也可以作⽤于⼀个Query
query.filter(User.name.in_(session.query(User.name).filter(User.name.like ('%ed%'))))
# 不在...中 not in
query.filter(~User.name.in_(['ed','wendy','jack']))
# is null 为空
query.filter(User.name==None)
query.filter(User.name.is_(None))
# 不为空 is not null
query.filter(User.name != None)
query.filter(User.name.isnot(None))
# 条件并列 and
from sqlalchemy import and_
query.filter(and_(User.name=='ed',User.fullname=='Ed Jones'))
# 或者是传递多个参数
query.filter(User.name=='ed',User.fullname=='Ed Jones')
# 或者是通过多次filter操作
query.filter(User.name=='ed').filter(User.fullname=='Ed Jones')
from sqlalchemy import or_ query.filter(or_(User.name=='ed',User.name=='wendy'))

外键&外键约束

# 通过 ForeignKey类来实现，并且可以指定表的外键约束
class Article(Base):__tablename__ = 'article'id = Column(Integer,primary_key=True,autoincrement=True)title = Column(String(50),nullable=False)content = Column(Text,nullable=False)# 外键 user.id  user 表 中的 id 字段uid = Column(Integer,ForeignKey('user.id'))def __repr__(self):return "<Article(title:%s)>" % self.titleclass User(Base):__tablename__ = 'user'id = Column(Integer,primary_key=True,autoincrement=True)username = Column(String(50),nullable=False)# 外键查询(原理)
article = session.query(Article).first()
uid = article.uid
user = session.query(User).get(uid)
print(user)
# 外键查询
user = session.query(User).filter(User.id == Article.uid).first()# 外键约束
RESTRICT：⽗表数据被删除，会阻⽌删除。默认就是这⼀项。
NO ACTION：在MySQL中，同RESTRICT。
CASCADE：级联删除。
SET NULL：⽗表数据被删除，⼦表数据会设置为NULL# 通过 ForeignKey类来实现，并且可以指定表的外键约束
class Article(Base):__tablename__ = 'article'id = Column(Integer,primary_key=True,autoincrement=True)title = Column(String(50),nullable=False)content = Column(Text,nullable=False)# 指定外键关系、执行外键约束删除关系uid = Column(Integer,ForeignKey('user.id',ondelete='CASCADE'))

数据表对应关系

# 1对 n 的关系from sqlalchemy import ForeignKey
from sqlalchemy.orm import relationshipclass Article(Base):__tablename__ = 'article'id = Column(Integer,primary_key=True)email_address = Column(String,nullable=False)user_id = Column(Integer,ForeignKey('users.id'))# 一对多的关系，backref 反向访问属性author = relationship('Author',backref="article")def __repr__(self):return "<Address(email_address='%s')>" % self.email_addressclass Author(Base):__tablename__ = 'author'id = Column(Integer,primary_key=True)name = Column(String(50))fullname = Column(String(50))password = Column(String(100))# 一对多的关系  relationship,  backref(反向查询)article = relationship("Article",backref="author")# 查询 (文章，作者)
article = session.query(article).first()
print(article.author)# 添加单条数据
user = Article(username = "lcl")
article = Article(title = "python",context ="xxxxx")
article.author = user
session.add(article)
session.commit()# 添加多条文章记录
user = User(username = "lcl")
article1 = Article(title="python1",context="xxxx1")
article2 = Article(title="python2",context="xxxx2")article1.author = user
article2.author = usersession.add(article1)
session.add(article2)
session.commit()# 1对1 的关系
class User(Base):__tablename__ = "user"id = Column(Integet,primary_key = True, autoincrement= True)username = Column(String(50),nullable = False)**# uselist= False 指定关系为 1 vs 1**extend = relationship("UserExtend",uselist= False)class UserExtend(Base):__tablename__ = "user_extend"id = Column(Integet,primary_key = True, autoincrement= True)school = Column(String(50))# 外键uid = Column(Integer,Foreignkey("user.id"))user = relationship("User",backref = "extend")# n 对 n 的关系
# 多对多，班级对老师，老师对班级
# 班级表 —— 中间表（班级表ID + 老师表 ID） —— 老师表
from sqlalchemy import Table
# 中间表定义
techer_class = Table("techer_classes",       # 中间表名Base.metadata,Column("techer_id",Interger,ForeignKey("techer.id"))   # 中间表字段Column("classes_id",Interger,ForeignKey("classes.id"))  # 中间表字段
)class Teacher(Base):__tablename__ = "teacher"id = Column(Integet,primary_key = True, autoincrement= True)name = Column(String(50))# 外键关系、指定中间表classes = relationship("Classes",backref = "teachers",secondary= teacher_classes)class Classes(Base):__tablename__ = "classes"id = Column(Integet,primary_key = True, autoincrement= True)name = Column(String(50))# 多对多数据的添加
teacher1 = Teacher(name= "lcl")
teacher2 = Teacher(name ="wzh")classes1 = Classes(name = "初级班")
classes2 = Classes(name = "进阶班")teacher1.classes.append(classes1)
teacher1.classes.append(classes2)teacher2.classes.append(classes1)
teacher2.classes.append(classes2)session.add(teacher1)
session.add(teacher2)
session.commit()# 查询老师对应的班级
teacher = session.query(Teacher).first()
print(teacher)
for i in teacher.classes:print(i)# 班级对应的老师
classes = session.query(Classes).first()
for i in classes.techers:print(i)

数据库高级查询

# 排序
articles = session.query(Article).order_by(Article.id).all()   # 升序
articles = session.query(Article).order_by(Article.id.desc()).all()    # 降序
articles = session.query(Article).order_by(-Article.id).all()  # 降序
for article in articles:print(articles)# 默认排序方法  - __mapper_args__  魔术方法
class Article(Base):__tablename__ = 'article'id = Column(Integer,primary_key=True,autoincrement=True)title = Column(String(50),nullable=False)__mapper_args__ = {"order_by" : id}
# 定义魔术方法后，查询你中无需 order_by
articles = session.query(Article).all()
for article in articles:print(articles)"""
limit : 可以限制每条查询的时候，只查询几条数据
offset : 可以限制查询数据的时候过滤掉前面多少条
切片 ： 可以对Query 对象使用切片操作，来获取想要的数据
"""
# limit 限制 —— 前三条数据
articles = session.query(Article).limit(3).all()
for article in articles:print(articles)# offset偏移量   查询 3-5条数据
articles = session.query(Article).offset(3).limit(3).all()
for article in articles:print(articles)# 切片 取 2-4 条
articles = session.query(Article).all()[2,5]
for article in articles:print(articles)# 分组、having、join方法
# group_by 分组、一般和聚合 函数连用
results = session.query(User.gender).group_by(User.gender).all()
results = session.query(User.gender,func.count(User.id)).group_by(User.gender).all()
for result in resultsprint(result)# having ,分组后过滤
results = session.query(User.age,func.count(User.id)).group_by(User.age).having(User.age<18).all()
print(results)# 子查询
# 查询和 李 相同的城市 和年龄的人
user = session.query(User).filter(User.username =="李").first()
print(user.city)
print(user.age)
result = session.query(User).filter(User.city == user.city,User.age == user.age).all()
for data in result:print(data)sub = session.query(User.city.label("city"),User.age.label("age")).filter(User.username =="李").subquery()
result = session.query(User).filter(User.city == sub.c.city,User.age == sub.c.age).all()

Flask - SQLAlchemy插件

# 插件安装
pip install flask-sqlalchemyfrom flask import Flask
from flask sqlachemy import SQLAlchemy
# localhost
HOSTNAME = '127.0.0.1'    # IP
PORT = '3306'            # 端口
DATABASE = 'demo0417'    # 数据库名称
USERNAME = 'root'        # 用户名
PASSWORD = 'root'        # 密码DB_URI = 'mysql+mysqlconnector://{}:{}@{}:{}/{}'.format(USERNAME,PASSWORD,HOSTNAME,PORT,DATABASE)app = Flask(__name__)# 创建引擎，加载配置文件 SQLALCHEMY_DATABASE_URL
# engine = create_engine(DB_URL)
app.config['SQLALCHEMY_DATABASE_URL'] = DB_URL
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False# 操作数据库，通过db 操作数据库
db = SQLAlchemy(app)# 创建模型（继承自 db.Model）
class User(db.Model):__tablename__ = 'users'id = db.Column(db.Integer,primary_key = True,autoincrement= True)name = db.Column(db.String(50))class Article(db.Model):__tablename__ = 'article'id = db.Column(db.Integer,primary_key = True,autoincrement= True)title = db.Column(db.String(50))# 定义外键uid = db.Colunm(db.Integer,db.Foreignkey('users.id'))# 表关联author = db.relationship('User',back='articles')# 将Model 映射到数据库中
db.create_all()# 数据添加
user = User(name = 'lcl')
article = Artcile(title = 'python')
article.author = user
db.session.add(article)
db.session.commit()# 查询数据
user = User.query.all()
print(user)
# 排序
users = User.query.order_by(User.id.desc()).all()
print(users)@app.route("/")
def index():return "首页"if __name__ == '__main__':app.run(debug = True)

性能优化

基准测试定义：测量和评估软件性能指标的活动，用于建立某时刻的性能基准，便于当系统发生软硬件变化时，评估变更带来的影响

对系统设置压力测试，用于评估服务器的处理能力

建立mysql服务性能基线

基准测试工具

工具： mysqlslap

# 参数命名mysqlslap --auto-generate-sql  # 由系统自动生成SQL脚本进行测试mysqlslap --auto-generate-sql-add-autoincrement   # 在生成的表中增加自增ID
mysqlslap --auto-generate-sql-load-type     # 指定测试中使用的查询类型
mysqlslap --auto-generate-sql-write-number  # 指定初始化数据时生成的数据量
mysqlslap --concurrency     # 指定并发线程的数量
mysqlslap --engine  # 指定要测试表的存储引擎,可以用逗号分割多个存储引擎
mysqlslap --no-drop     # 指定不清理测试数据
mysqlslap --iterations  # 指定测试运行的次数
mysqlslap --number-of-queries   # 指定每一个线程执行的查询数量
mysqlslap --debug-info  # 指定输出额外的内存及CPU统计信息
mysqlslap --number-int-cols     # 指定测试表中包含的INT类型列的数量
mysqlslap --number-char-cols    # 指定测试表中包含的varchar类型的数量
mysqlslap --create-schema   # 指定了用于执行测试的数据库的名字
mysqlslap --query   # 用于指定自定义SQL的脚本
mysqlslap --only-print  # 并不运行测试脚本,而是把生成的脚本打印出来# 测试案例
mysqlslap --concurrency=1,50,100,200 --iterations=3 --number-int-cols=5 --number-char-
cols=5 --auto-generate-sql --auto-generate-sql-add-autoincrement --engine=myisam,innodb
--number-of-queries=10 --create-schema=test

explain 解析语句

定义：模拟优化器执行 sql 查询语句，分析查询语句的表结构性能瓶颈

解析内容：

表的读取顺序

数据读取操作的操作类型

哪些索引可以被使用

哪些索引实际被使用

表之间的引用

每张表有多好啊行被优化器查询

explain select * from t1,t2,t3 where t1.id=t2.id and t1.id = t3.id and t1.other_column='';

explian语句解析

id— 表的读取加载顺序（id相同、执行顺序由上而下，id不同、id值越大优先级越高、越先被执行）

select_type — 数据读取操作的操作类型（simple 简单的查询、primary 查询中若包含任何负责的子部分、最外层查询则被标记，subquery 在select 或where列表中包含了子查询，union 若第二个select出现在union之后,则被标记为union，union result 从union表获取结果的select）

Sqlmap探测工具

功能定义：一种安全探测测试工具，用于发现SQL注入的安全漏洞，长用来进行安全扫描

基本操作

# 程序开启（在文件程序对应目录下）
python sqlmap.py # 查看当前数据库版本信息
"""
0：只显示python 的tracebacks 信息、错误信息、关键信息
1：显示普通信息，和警告信息
2：显示调试信息 [debug]
3：显示注入使用的攻击载荷[payload]
4：显示HTTP请求头
5：显示http响应头
6：显示HTTP响应体
"""
python sqlmap.py --version# sqlmap直连数据库（用户名、密码、端口地址、数据库名字）
python3 sqlmap.py -d "mysql://用户名:密码@地址:端口/数据库名字" -f --banner --dbs --users# sqlmap 探测定向的url地址
"""
探测分7级（0-6），参数用V标识，级别越高，探测的东西越多，时间越长，默认为V1- u : 指定单一url地址
- m : 探测多个目标（text文件保存在sqlmap文件中，可以保存多行目标, 目标地址需要和数据库有交互的地址）
- r : 指定httl交互文件，文件中保存请求头信息（request header(view parsed)）
- c ：从配置文件sqlmap.conf 中读取目标文件（需要先修改target url 地址）
--method ：http请求方法（get、post、cookie、user-agent）
"""
python sqlmap.py -u "地址"  --banner   -v2
python sqlmap.py -u "地址"  -2   --bannersqlmap -m "文件路径" --banner# 针对post方法提交参数的地址通过提交参数来进行测试
sqlmap -u "url" --data="uname=admin&passwd=amdin&submit=Submit" --banner# sqlmap中设置cookie参数
#对登陆界面进行探测的时候需要携带  cookie信息  对登陆之后网站进行探测 也需要携带cookie 信息--cookie "cookie值" # 指定cookie值
--cookie-del  # 删除cookie值
--load-cookies # 在文件中加载cookie
--drop-set-ookie  # 设置set-cookie的值#sqlmap中设置 user-agent
sqlmap -u "url" --data="uname=admin&passwd=amdin&submit=Submit" --user-agent
# 随机设置请求user-agent
sqlmap -u "url" --data="uname=admin&passwd=amdin&submit=Submit"  -- random -agent# sqlmap 设置代理（ip代理）
sqlmap -u "url" --data="uname=admin&passwd=amdin&submit=Submit" --proxy "http:// $haproxy ip：prot"
sqlmap -u "url" --data="uname=admin&passwd=amdin&submit=Submit" --proxy-file
#设置http代理服务器认证信息
sqlmap -u "url" --data="uname=admin&passwd=amdin&submit=Submit" --proxy-cred user:pwd
--ignore-proxy # 忽略系统范围内的代理服务器# qlmap 设置探测延迟
-- delay 0.5  # 设置延迟0.5秒# sqlmap 中设置超时
--timeout 10.5 # (超过一段时间请求没有响应，此测试跳过)# sqlmap 设置超时连接次数
--retries  count   # 默认为3次# sqlmap 中设置随机参数(每次请求期间随机更改其参数名称（长度和类型根据原始值保持一直）)
--randomize "参数名称"# sqlmap  忽略 错误站点提示 401
--ignore -401  # 继续探测# 指定网站请求的参数分隔符
--param-del = "分隔符"

常用检索参数

#    获取后端数据库的版本信息     -- banner  -b# 获取DBMS当前用户
--current -user#    获取当前数据库名称
--current -db#  获取当前主机名
-- hostname#    探测当前用户是否是数据库管理员
--is -dba#  会先列举用户，在列举用户密码的hash值
--passwords#    枚举 DBMS用户  所有用户
--users#    列举数据库名
--dbs#  枚举数据库表
--tables      #   数据库名字
#  指定具体数据库
-D# 枚举数据表列
--columns
-T  # 指定数据库表#   枚举数据值
-- dump#    枚举schema 信息
--schema    # （列举数据库管理系统模式，模式列表包括数据库、表、列、触发器、和他们各自的类型。同样的  可以通过参数 --exclude-sysdbs  排除系统数据库）
-sysbds   # 除去数据库系统表#   检索数据表数量
--count  #（如果用户只想知道表数据条数）#    获取数据信息
--start     --stop  （--start1 --stop3）  # 返回前三条数据#    设置条件获取信息
--where
#   暴力破解表名
--common -table#    暴力破解列名
# 1、版本小于5.0的无法查询
# 2、数据库 用户的权限过低 无法读取表名
--common-columns#   读取文件
--file-read   # 路径 读取对应文件内容（此路径为绝对路径）#    检索所有信息   参数
-a
--all   # 返回所有的检索信息

性能优化

# 查询参数
python sqlmap -hh# 设置持久化http连接（长连接）
--keep-alive
python sqlmap.py -u "地址"  --keep-alive --banner   -v2 # 设置不接收http body（不接收消息体）
--null -connection
python sqlmap.py -u "地址"  --keep-alive --null-connection --banner   # 设置多线程
--thread = 3
python sqlmap.py -u "地址" --thread=3 --banner# 一键优化(同时添加多个参数)
-o  (--keep-alive --null-connection --threads = 3)
python sqlmap.py -u "地址" -o --banner#**sqlmap自定义检测级别**# 设置探测等级 (1-5)
# 大于2时、会对cookie等参数进行测试、大于3时，会使用user-agent 和 referer（跳转） 进行测试
--level = 2
python sqlmap.py -u "地址" -o --banner --level = 2# 设置风险等级
--risk = 2# 指定探测参数
python sqlmap.py -u "地址" -p "id,user-agent" --banner# 跳过某些注入参数
python sqlmap.py  -u "地址" -skip "参数名称"# 对注入点存在uri中的，在参数后面加 # 进行指定探测参数
python sqlmap.py -u "127.0.0.1/id#/user/"# sqlmap检索DBMS（指定探测数据库）
sqlmap -u "url" --data="uname=admin&passwd=amdin&submit=Submit" --dbms "数据类型"# 执行操作系统
sqlmap -u "url" --data="uname=admin&passwd=amdin&submit=Submit" --os # 无效值参数的替换(替换原有的、执行替换的部分)
--invalid-bignum
--invalid-logical
sqlmap -u "url" --data="uname=admin&passwd=amdin&submit=Submit and 恶意sql语句" "# 自定义注入负载位置
--prefix "设置sql注入payload前缀"
sqlmap -u "127.0.0.1/lesson/id=1" --prefix
--suffix "设置sql注入payload后缀"# 设置Tamper参数
sqlmap -u "127.0.0.1/lesson/id=1" --tamper "脚本名称"# 设置DBMS认证
--dbms-cred = username

指定注入参数

 #  参数  --technique# 默认情况下所有的方式全部使用一遍
B：Boolean-based blind   # （布尔型注入）
E：Error-based  # （报错型注入）
U：Union query-based   # （可联合查询注入）
S：Stacked queries  # （可多语句查询注入）
T：Time-based blind  # （基于时间延迟注入）
Q：Inline queries  # （嵌套查询注入）# 设置时间盲注延迟时间（默认5s）
--time-sec# 设置union联合字段数
--union-cols 12-18# sqlmap设置union字符
-union-char# 设置联合查询表
--union-from "表名"  # 指定联合查询的表名# 探测目标指纹信息
-f
--fingerprint

MYSQL数据库应用详解相关推荐

如何查看mysql数据库的引擎/MySQL数据库引擎详解
一般情况下,mysql会默认提供多种存储引擎,你可以通过下面的查看: 看你的mysql现在已提供什么存储引擎: mysql> show engines; 看你的mysql当前默认的存储引擎: m ...
silverlight mysql_Silverlight中衔接MySQL数据库实例详解
Silverlight中衔接MySQL数据库实例详解日期:2010年5月25日作者: 本文将重点讲述Silverlight中衔接MySQL数据库实例,这在RIA开发中比拟根底,但是也是比拟首要的内 ...
ruby中DBI连接MySQL数据库步骤详解
2019独角兽企业重金招聘Python工程师标准>>> 1.准备工作. 首先下载DBI接口:http://rubyforge.org/frs/download.php/12368/d ...
MySQL数据库备份详解
目录 1 备份单个数据库 1.1 备份oldboy数据库 1.2 优化备份文件大小减少输出注释(debug调试) 1.3压缩备份(推荐) 1.4 备份单个数据库小结 2 mysqldump备份 2.1 ...
python3连接mysql,python3连接MySQL数据库实例详解
本文实例为大家分享了python3连接MySQL数据库的具体代码,供大家参考,具体内容如下 #python3连接MySQL实例 import pymysql """导入连 ...
mysql-5.2 lib_Centos 5.2下安装多个mysql数据库配置详解
一.编译安装第一个MySQL 5.1.33 cd /opt /usr/sbin/groupadd mysql /usr/sbin/useradd -g mysql mysql -s /bin/nolo ...
mysql zrm 配置_利用MySQL-zrm来备份和恢复MySQL数据库方法详解
MySQL ZRM 工具是用PERL写的可以全部和增量备份MySQL数据库的一个强大工具. 还可以做快照,不过我现在没有条件做.等以后有可以做了再补上. 其实具体要说的也没啥,我只是做了点测试. 这里 ...
MySQL数据库引擎详解
作为Java程序员,MySQL数据库大家平时应该都没少使用吧,对MySQL数据库的引擎应该也有所了解,这篇文章就让我详细的说说MySQL数据库的Innodb和MyIASM两种引擎以及其索引结构.也来巩 ...
mysql数据库约束详解_基于MySQL数据库的数据约束实例及五种完整性约束介绍
为了防止不符合规范的数据进入数据库,在用户对数据进行插入.修改.删除等操作时,DBMS自动按照一定的约束条件对数据进行监测,使不符合规范的数据不能进入数据库,以确保数据库中存储的数据正确.有效.相容. ...
MySQL数据库基础详解
文章大纲一.数据库简介二.Mysql数据库简介三.Mysql安装与服务启动(Windows版本) 四.Mysql图形化工具五.Mysql存储引擎精讲六.Mysql数据类型介绍七.Mysql ...

MYSQL数据库应用详解

常用工具

架构演变

SQL基本使用

SQL约束

常用关键字

SQL 增删改查

视图增删改查

SQL 索引

SQL 事务

SQL 权限控制

存储引擎

服务架构说明

日志说明

MYSQL主从配置

数据库的分区

Range分区

Hash 分区

List 分区

交互框架

Pymysql

SQLAlchemy

性能优化

基准测试工具

explain 解析语句

基本操作

常用检索参数

性能优化

指定注入参数

MYSQL数据库应用详解相关推荐

最新文章

热门文章

MYSQL数据库应用详解

常用工具

架构演变

SQL基本使用

SQL约束

常用关键字

SQL 增删改查

视图 增删改查

SQL 索引

SQL 事务

SQL 权限控制

存储引擎

服务架构说明

日志说明

MYSQL主从配置

数据库的分区

Range分区

Hash 分区

List 分区

交互框架

Pymysql

SQLAlchemy

性能优化

基准测试工具

explain 解析语句

基本操作

常用检索参数

性能优化

指定注入参数

MYSQL数据库应用详解相关推荐

最新文章

热门文章

视图增删改查