mysql基础笔记整理

----------------------------------------------数据库复习--------------------------------------
#-----------------------------------------数据完整性-------------------------------#
7个约束:主键，外键，非空，唯一，自增，限定值，默认值;
主键就是表中的一列或多列的一组，其值能唯一的标识表中的每一行(唯一且不为空)关系模型理论要求必须为每个表定义一个主键,任何列或列的组合都可以充当主键
#创建DATABASE
CREATE DATABASE IF NOT EXISTS movie;
USE movie;
#创建TABLE
CREATE TABLE IF NOT EXISTS data
(
id INTEGER PRIMARY KEY, #可追加数据的完整性的属性
name varchar(10), #可追加数据的完整性的属性
CONSTRAINT id_name #声明外键约束时,要进行取别名操作---以便日后删除
FOREIGN KEY(id) REFERENCES struct(id) #进行外键约束的两个字段都必须进行主键的约束
ON DELETE CASCADE #cascade的意思:删除或者修改主类时子类进行同步操作
ON UPDATE CASCADE #no action:创建外键时的默认操作或者是 ON DELETE SET NULL;删除时进行置空处理
);
#取别名的创建表
CREATE TABLE IF NOT EXISTS struct
(
id INTEGER PRIMARY KEY AUTO_INCREMENT,
name varchar(10)
);
#查看TABLE----大概结构
SHOW TABLES;
#插入数据--插入的方式有三种
#第一种全部插入
INSERT INTO data VALUES(1,"zhang");
INSERT INTO data VALUES(1,"san");
INSERT INTO struct VALUES(1,"170CLASS");
#采用部分插入的方式插入
INSERT INTO data(name) VALUES("san");
INSERT INTO data(name) VALUES("yong");
#多个同时插入
INSERT INTO struct(name) VALUES("zhang"),("san"),("yong");
#查看数据
SELECT * FROM data;
SELECT * FROM struct;
SELECT * FROM text WHERE name like "张%"; #特指以张开头的一列
SELECT * FROM text WHERE id BETWEEN 1 AND 12;
#更新数据
UPDATE data SET id=12 where id=1;
#删除数据--两种情况(字段为空与字段不为空)
DELETE FROM data where id=1; #字段不为空时，直接用=即可
DELETE FROM data WHERE id is null; #字段为空时，要用is
#修改列的属性
ALTER TABLE data MODIFY COLUMN id ENUM('666','999') DEFAULT '666'; #设定在限定的范围内设置默认值
ALTER TABLE data MODIFY COLUMN id INTEGER DEFAULT '1000'; #可以不在限定的范围内修改值
ALTER TABLE data MODIFY COLUMN id INTEGER NOT NULL; #修改为非空属性
ALTER TABLE data MODIFY COLUMN id INTEGER; #修改为空属性
ALTER TABLE data ADD PRIMARY KEY(`id`); #添加主键---唯一性标识
ALTER TABLE data ADD PRIMARY KEY (`id`,`name`); #复合主键(整体不能为空且唯一)
ALTER TABLE data ADD CONSTRAINT id_name PRIMARY KEY(`id`,`naem`); #添加一个别名
ALTER TABLE data DROP PRIMARY KEY; #一个表中只能有同一个主键，因此不需要指定字段
ALTER TABLE struct ADD CONSTRAINT id_name PRIMARY KEY(id,name); #添加一个复合主键
ALTER TABLE struct ADD CONSTRAINT id_name FOREIGN KEY(id) REFERENCES class(classId); #添加外键
ALTER TABLE struct DROP FOREIGN KEY id_name; #删除外键
#添加自增属性----一般把主键给一个int字段，在添加自增属性可实现自增效果
ALTER TABLE data ADD PRIMARY KEY AUTO_INCREMENT(`id`);
#添加外键约束----->两个表一个表参考另外一个
INSERT INTO data VALUES(1,"zhang"); #然后在子类中加入数据，而且由于外键约束的原因导致子类中的id必须和主类中的id值一样才能正确的进行插入！
INSERT INTO struct VALUES(1,"51CLASS"); #必须主类中先放有数据才行
#修改主类引起子类的自动修改
UPDATE struct SET id=12 where id=1; #主类被修改后子类也会改变
#查看某个表的结构
SHOW CREATE TABLE data;
DESC data; #字段信息
#限制值约束:也叫范围约束
ALTER TABLE data MODIFY COLUMN id ENUM('666','999') DEFAULT '666'; #设定在限定的范围内设置默认值
ALTER TABLE data MODIFY COLUMN id INTEGER DEFAULT '1000'; #可以不在限定的范围内修改值
#默认值约束
ALTER TABLE data MODIFY COLUMN id INTEGER DEFAULT '1000'; #可以不在限定的范围内修改值
#删除TABLE
DROP TABLE data;
DROP TABLE struct;

-------------------------------------------------------#单表查询---------------------------------------------
#DQL--查询某些字段
SELECT `name` FROM data; #只查询name
##DQL--带条件查询
SELECT * FROM data where id=12; #利用到了where子句
SELECT * FROM data WHERE id is NULL; #为空
SELECT * FROM data WHERE id!=12; #不等于
SELECT * FROM data WHERE id=12 AND `name`='zhang'; #查询name=‘zhang’ AND id=12
SELECT * FROM data WHERE id BETWEEN 1 AND 12; #查询id在2<=id<=12
CREATE TABLE IF NOT EXISTS text
(
id INTEGER,
name VARCHAR(10)
);
#插入数据
INSERT INTO text values(1,"张三勇"),(2,"张"),(3,"三全");
#更新数据
UPDATE text SET id=100 WHERE id BETWEEN 1 AND 12; #多个数据同时修改
#查看数据
SELECT * FROM text WHERE id BETWEEN 1 AND 12; #查询id值在1到12之间字段(包括边界)
SELECT `id` FROM text;
SELECT * FROM text WHERE name like "张%"; #表示以张开头的字符串
SELECT * FROM text WHERE name like "张_"; #只表示张
SELECT * FROM text WHERE name like '[张三]%'; #类似于正则表达式的操作，还有[^abc]%等等
SELECT * FROM text WHERE name like '%三%'; #表包含‘三’的字段
SELECT * FROM text WHERE name is NULL; #字段为空的查询
#排序查询
SELECT * FROM text ORDER BY id desc; #以降序排序的方式查看表
SELECT * FROM text ORDER BY id asc,id asc; #以升序排序的方式查看表
#分组查询
SELECT * FROM text GROUP BY name #通过名字分组去查询
HAVING price>=100; #在这里的HAVing相当于WHERE(因为分组之后不能再用WHERE子句了)
例如: SELECT price FROM customs
WHERE name like "张%"
GROUP BY name HAVING price>=300;
#分页查询
SELECT * FROM text ORDER BY id DESC limit 2; #排序后只取前两个
#去重查询
SELECT DISTINCT id FROM text; #去重查询-----一般用在单表查询
#合并查询------------------UNION与UNION ALL
UNION #会合并相同项
UNION ALL #不会合并相同项
SELECT 1,'zhang'
UNION
SELECT 2,'san'
UNION
SELECT 3,'yong';
SELECT * FROM text WHERE id=1 OR name like '张%';
#相当于 UNION == OR
SELECT * FROM text WHERE id=1
UNION
SELECT * FROM text WHERE name like "张%";
-------------------------------------------------#多表查询-----------------------------------------------
CREATE DATABASE IF NOT EXISTS school;
use school;
CREATE TABLE IF NOT EXISTS class
(
classId INTEGER,
className VARCHAR(10)
);

CREATE TABLE IF NOT EXISTS student
(
claId INTEGER,
stuId INTEGER,
stuName VARCHAR(10)
);

INSERT INTO class VALUES(1,"51Class"),(2,"170Class"),(3,"140Class");
INSERT INTO class(className) VALUES("1806102");

INSERT INTO student VALUES(2,4,"zhang"),(1,10,"san"),(3,10,"yong");
INSERT INTO student(stuId,stuName) VALUES(100,"zsy");

DELETE FROM student WHERE stuName like 'zsy';

#联合查询
#内连接:多个表合并成一张表(不会出现笛卡尔积)，缺点:不满足ON后条件的表中的字段不会被合并
SELECT class.`className`,student.`stuName` FROM class INNER JOIN student
ON class.classId=student.claId;

SELECT * FROM student INNER JOIN class ON class.classId=student.claId; #这里有个小小的知识点:INNER... JOIN ... ON...
#就是将两个表拼接起来，相当于在某一个表的基础上，多加了几个字段
#一般是增加 INNER JOIN 前面的表，并与后面的表对齐
SELECT class.`className`,student.`stuName` FROM student,class; #没有进行连接合并，查找的时候又分开了

#右连接----以RIGHT JOIN右边的表为基础，可以查询到右边的表中不满足ON条件的字段
SELECT * FROM class RIGHT JOIN student ON class.classId=student.claId;

#左连接----以LEFT JOIN左边的表为基础，可以查询到左边的表中不满足ON条件的字段
SELECT * FROM class LEFT JOIN student ON class.classId=student.claId LIMIT 2;

#全连接 ----左边与右边的表中不满足ON条件的都可以查询出来
SELECT * FROM class RIGHT JOIN student ON class.classId=student.claId
UNION
SELECT * FROM class LEFT JOIN student ON class.classId=student.claId
ORDER BY classId ASC;

#别名AS查询-----作用:当多个表具有相同的字段名时，可用别名区分
SELECT id AS num,name AS LastName FROM text;

#删除表
DROP TABLE student;
DROP TABLE class;

例子:
CREATE TABLE staff
(
id INTEGER PRIMARY KEY,
pastId INTEGER,
`name` VARCHAR(10),
CONSTRAINT `forein`
FOREIGN KEY(pastId) REFERENCES past(id)
ON UPDATE CASCADE
ON DELETE CASCADE
);

CREATE TABLE past
(
id INTEGER PRIMARY KEY,
`name` VARCHAR(10)
);

INSERT INTO staff VALUES(1,1,"张三"),(2,2,"李四"),(3,1,"王五");
INSERT INTO past VALUES(1,"销售部"),(2,"研发部");

SELECT staff.name AS "职工名字",past.name AS "部门名字" FROM staff INNER JOIN past ON staff.pastId=past.id;
DELETE FROM staff WHERE `name`="张三"; #不管删除的是主表
DELETE FROM past WHERE `name`="销售部"; #还是副表(主表与副表的操作(CASCADE)(删除、更新等)都是同时进行的)

-----------------------------------------#数据库数-----------------------------------------------
DROP DATABASE school;
CREATE DATABASE IF NOT EXISTS mall;
use mall;
CREATE TABLE IF NOT EXISTS customs
(
id INTEGER PRIMARY KEY,
price DOUBLE,
name VARCHAR(10)
);

ALTER TABLE customs DROP PRIMARY KEY;
ALTER TABLE customs MODIFY COLUMN id INTEGER PRIMARY KEY AUTO_INCREMENT;
DESC customs;

INSERT INTO customs(price,name) VALUES
(102.2,"zhang"),
(23.34,"san"),
(323.3,"yong"),
(123,"zhang");

#求和函数
SELECT SUM(price) FROM customs WHERE name like "zhang";
#求平均数
SELECT AVG(price) FROM customs WHERE name like "zhang";
#求最大值
SELECT MAX(price) FROM customs;
#求最小值
SELECT MIN(price) FROM customs;
#求前三大值
SELECT price FROM customs ORDER BY price DESC LIMIT 3;

----------------------------------------------#视图-----------------------------------------------
作用：主要用来保存一个临时的结果，方便以后去查看(因为临时结果会随时消失，要想长久的保存起来,便于以后查看以做参考等等，就需要就它保存起来)
USE movie;
CREATE TABLE IF NOT EXISTS student(claId INTEGER,stuId INTEGER PRIMARY KEY,stuName VARCHAR(10)); #创建两个表
CREATE TABLE IF NOT EXISTS class(classId INTEGER PRIMARY KEY,className VARCHAR(10));
INSERT INTO student
VALUES(1,12,"zhang"),(2,10,"san"),(3,4,"yong");
INSERT INTO class
VALUES(1,"170"),(2,"140"),(3,"51");
SELECT * FROM data; #得到临时的结构集---->保留到视图中,留作后续查询和修改
CREATE OR REPLACE VIEW look #----->相当于取别名
AS #创建一个视图----->如果存在的话就替换，不存在则创建
SELECT * FROM student INNER JOIN class ON student.`claId`=class.`classId`;
#查看视图
SELECT DISTINCT * FROM look ORDER BY claId ASC LIMIT 2;
SELECT stuName,className FROM look;
SELECT * FROM student;
#更新数据
UPDATE look SET stuName='san' WHERE stuName="zsy"; #更新视图中的数据时，表中的数据也同时被修改了
#视图中的数据与表中的数据是一一对应的，视图被修改了则表中的数据也会发生改变
#删除数据
DELETE FROM look WHERE claId=1; #通过连接的方式合并的数据表不能进行删除
#修改视图
ALTER VIEW look
AS
SELECT * FROM student;
#查看视图的结构
SHOW CREATE VIEW look; #与表的操作基本一样
DESC look;
#删除视图
DROP VIEW look;
#------------------------------------------#索引----------------------------------------------
#目的:用空间换取时间------>提高查找效率 用的哈希表--BTREE
#比如说每个表中都有一个主键(标准的写法),那么该主键就是一个索引，在查询的时候，查找主键比查找其他的字段得到速度更快
#因为数据库对每个索引都有一个特定的空间或者结构去存储它---比如用BTREE(哈希表)等等，可以大大的提高查找效率
#但是需要一定的空间----相当于以空间换取时间---相当于m3u8文件一般，保存着文件的索引，从而查找起来更快
#<-------------------------------------------------------------------------------------------->
# 1、普通索引 数值为null，也可以不唯一
# 2、唯一索引 unique 唯一，但是可以为空 ---->相当于唯一约束
# 3、主键索引 唯一并且不能为null PRIMARY KEY ---->相当于主键约束
# 4、全文索引 用于文本(字符串)
USE movie;
SHOW INDEX FROM student;
SHOW INDEX FROM class;

#添加索引
CREATE TABLE `text`
(
id INTEGER PRIMARY KEY, #在这个地方数据库会自动添加一个主键索引
name VARCHAR(10)
);
ALTER TABLE `text` ADD CONSTRAINT zhang UNIQUE(`name`); #添加一个普通的索引
ALTER TABLE `text` DROP INDEX `zhang`; #删除索引
ALTER TABLE `text` ADD UNIQUE(`name`); #不加别名
ALTER TABLE `text` DROP `name`; #删除唯一性索引，可以不用加上INDEX
ALTER TABLE `text` DROP PRIMARY KEY; #及删除主键约束又删除了主键索引
ALTER TABLE `text` ADD PRIMARY KEY(`id`); #添加主键索引
#在此声明一个小的知识点
#着重号的作用``，与关键字作区分，如表明叫 insert 与关键字INSERT 一样则用 `insert`做区分
CREATE TABLE `text`;
#添加普通索引
ALTER TABLE class ADD INDEX `index`(className);
ALTER TABLE class ADD INDEX `id`(`className`); #添加普通索引-记得一定要添加INDEX关键字
#删除普通索引
ALTER TABLE class DROP INDEX `index`; #删除普通索引-也记得一定要添加INDEX关键字
#查看数据库支持的引擎:---数据库存储、管理、和保护数据的方式
SHOW ENGINES;
#myisam 之前用的，不支持事务、不支持外键、访问速度比较快
#innoDB 支持事务和外键，支持崩溃恢复操作
#memory 表格放在内存中，运算效率高：关闭服务时，这个数据会丢失 支持hash/btree;
#创建引擎
CREATE TABLE `engine`
(
id INTEGER
)ENGINE=MyISAM DEFAULT CHARSET="UTF8";
#修改引擎
ALTER TABLE `engine` ENGINE=InnoDB;
DESC `engine`;
#------------------------------------------#存储过程----------------------------------------------
c语言--面向过程的语言--->函数 一段c语言的语句
作用:封装一段代码
存储过程:相当于没有返回值的函数:参数 in(输入--->传入值的) out(输出--->传出值的) inout(既要传值进来又要传值出去)
cin.get(ch) 值接受函数的值
cout<<"hello"<<endl; 值给函数 procedure
CREATE PROCEDURE test() #创建存储过程---test()相当于函数名(和创建视图差不多)
SELECT * DROM data; #相当于函数体
CALL test(); #调用存储过程
ALTER PROCEDURE test() #修改存储过程
SELECT * FROM movie;
DROP PROCEDURE test; #删除存储过程
#关于多个存储过程 有多个语句 DELIMITER:定界符
<--------------------------------------------------------------------------------------------------->
#创建一个无参数的存储过程
DELIMITER $ #创建新的分隔符(默认的是;,如果采用;则会导致BEGIN END中的语句只会执行一句就结束了,还会报错)
CREATE PROCEDURE test() #创建存储过程的时候,里面的语句并不会被执行，只有当在CALL的时候才会执行
BEGIN
INSERT INTO class VALUES(5,"1806101");
SELECT * FROM class ORDER BY classId ASC;
END$
DELIMITER ; #还原默认的分隔符
CALL test();
<--------------------------------------------------------------------------------------------------->
#创建一个有参数的存储过程 (procedure程序--步骤--过程)
DELIMITER $
CREATE PROCEDURE test(IN num INTEGER,IN Name VARCHAR(20)) #IN 表示要传值进来
BEGIN
INSERT INTO class VALUES(num,Name);
SELECT * FROM class ORDER BY classId ASC;
END$
DELIMITER ;
CALL test(12,"1806110"); #调用存储过程
<-------------------------------------------变量-------------------------------------------------------->
变量分为:局部变量(在BEGIN END中定义的变量)
用户变量:只在此次连接中起作用
全局变量:在mysql服务中都起作用
DECLARE data INTEGER DEFAULT 0; #用DECLARE关键字声明一个局部变量
SET data = num; #赋值使用SET关键字
例如:局部变量
DELIMITER $
CREATE PROCEDURE test(IN num INTEGER,IN Name VARCHAR(20)) #IN 表示要传值进来
BEGIN
DECLARE data INTEGER DEFAULT 0;
SET data = num;
SELECT data;
END$
DELIMITER $
CALL test(100,"111");
##################用户变量:前面需要加上@
SET @x=12;
DELIMITER $
CREATE PROCEDURE test(IN num INTEGER,IN Name VARCHAR(20),OUT out INTEGER) #IN 表示要传值进来
BEGIN
DECLARE data INTEGER DEFAULT 0;
SET data = num;
SELECT data;
END$
DELIMITER $
CALL test(100,"111",@x); #用@x去匹配OUT传出来的值
SELECT @sum := @x+45 AS '结果'; #这里的:=相当于赋值，因为不能使用SET
又如:
SET @x=12;
SET @y=13;
SELECT @x:=@x+@y AS '结果';
##################会话变量:
SHOW SESSION VARIABLES; #查看系统变量
SHOW GLOBAL VARIABLES; #查看全局变量
#################全局变量:前面需要加入两个@
SELECT @@version; #查看系统的版本
SELECT VERSION(); #以函数的形式查看系统的版本
SHOW GLOBAL VARIABLES;
SELECT @@tmpdir; #查看存储路径
<-------------------------------------------函数-------------------------------------------------------->
函数:可以有参数也可以没有，但是一定有返回值，参数类型一定是IN
CREATE FUNCTION te(num INTEGER)RETURNS INT
RETURN num+100;
SELECT te(100); #函数的调用要用SELECT
DROP FUNCTION te; #删除函数
<-------------------------------------------触发器-------------------------------------------------------->
USE movie;
SHOW TABLES;
SELECT * FROM student;
#触发器:只要满足某个条件就会立即调用执行(不用手动去调用) 多用在表格的插入、删除、更新
#触发器不能做查询操作(返回结果的操作)
#触发器有两种条件:AFTER触发器、BEFORE触发器
#触发器有三种类型:INSERT触发器、UPDATE触发器、DELETE触发器
#AFTER触发器:在数据库进行插入、删除、更新之后再触发，触发器无法影响它的插入、删除、更新
#BEFORE触发器:在进行插入、删除、更新之前先进行触发器的操作
#触发器可以解决的问题:对两个相连的表,如果其中一个表的数据发生改变时,
#另一个表的数据也要发生变化，这样操作会比较麻烦，此时可以用触发器对其进行同步操作
#触发器中不能对同一个表进行操作Can't update table 'class' in stored function/trigger because it is already used by statement which invoked this stored function/trigger.

#两个表同时进行INSERT
DELIMITER $ #重定义分隔符
CREATE TRIGGER zhang #创建一个触发器
AFTER INSERT
ON class FOR EACH ROW #触发器发动的条件
BEGIN
INSERT INTO student VALUES(1,12,"zhang");
END
$
DELIMITER ; #还原分隔符
DROP TRIGGER zhang;

#两个表同时进行UPDATE
DELIMITER $ #重定义分隔符
CREATE TRIGGER san #创建一个触发器
AFTER UPDATE
ON class FOR EACH ROW #触发器发动的条件
BEGIN
UPDATE student SET claId=102 WHERE claId=3;
END
$
DELIMITER ; #还原分隔符
DROP TRIGGER san;

#两个表同时进行DELETE
DELIMITER $ #重定义分隔符
CREATE TRIGGER yong #创建一个触发器
AFTER DELETE
ON class FOR EACH ROW #触发器发动的条件
BEGIN
DELETE FROM student WHERE claId=102;
END
$
DELIMITER ; #还原分隔符
DROP TRIGGER yong;

#在插入/删除/更新之前
DELIMITER $
CREATE TRIGGER zsy
BEFORE INSERT
ON class FOR EACH ROW
BEGIN
IF new.classId<0 THEN
SET new.className="学号不能为空"; #相当于对要执行的语句进行了拦截修改再执行
END IF;
END
$
DELIMITER ;
DROP TRIGGER zsy;

#在执行一条语句之前先执行另一条语句
DELIMITER $
CREATE TRIGGER ctf
BEFORE INSERT
ON class FOR EACH ROW
BEGIN
IF new.classId<0 THEN
INSERT INTO student VALUES(1,12,"zhang"); #相当于在执行一条语句之前先执行另一条语句，两条语句都会执行(但不能是同一个表)
END IF;
END
$
DELIMITER ;
DROP TRIGGER ctf;

#.......其他的和AFTER一样，只要注意不能对同一个表进行操作即可