MYSQL数据库(知识点+语法+用法+练习汇总 全 )

#数据库：数据的仓库。

#数据库类型划分：
#    关系型数据库：
#        每行数据代表一个对象信息，每列表示该对象的不同属性。
#    非关系型数据库：
#        以键值对方式存储数据

#数据库的专业术语：
#    以关系型数据库为例：
#    数据库系统  > 数据库管理系统 > 数据库 > 表 > 数据

#常用的关系型数据库：
#   后台使用C、C++、C#等高级编程语言，通常会使用sqlserver数据库
#   后台使用java高级编程语言，通常会使用mysql、oracle、DB2数据库
#非关系型数据库：
#   mongdb、redis

#不管是哪种关系型数据库，都是使用SQL语句[数据库脚本语言]。

#安装数据库：
#    先装服务器
#        提供服务的，数据来源
#        服务器会自带命令行客户端[字符界面]
#    再装客户端
#        获取服务，获取数据[图形化界面]

#mysql数据库的最高权限账号是 root   root
#编写sql语句的文件称为数据库脚本文件，后缀名.sql

#数据库使用：
#1、启动服务
#     (1)右击我的电脑 --> 管理 --> 服务 --> MySQL启动
#     (2)右击任务栏 --> 任务管理器 --> 服务 --> MySQL启动
#     (3)进入win+r运行窗口，敲cmd进入字符界面，输入指令：net start mysql

#2、登录数据库
#   (1)使用服务端自带的字符界面：CommandLine
#        默认使用的是最高权限账号：root 不用输入，只需输入密码。
#   (2)使用图形化界面客户端：不是服务器自带的，需要另安装
#        输入账号密码   [以sqlyog为例]
#   (3)在window提供的字符界面中登录
#        敲指令：mysql -u root -proot

#3、创建账号、分配权限
#   如果是在界面上维护：通过系统数据库mysql下面的user表，维护一条记录即可
#   使用SQL脚本语句维护：
#       创建登录用户：
#       create user '用户名'@'localhost' identified by '密码';
        CREATE USER 'ABCD'@'localhost' IDENTIFIED BY '123456';
#       给登录账号分配访问数据的权限：
#       grant 权限 on 数据库对象 to 用户
        GRANT INSERT,UPDATE,DELETE,SELECT ON mysql.user TO 'ABCD'@'localhost'  

#4、创建数据库
#   (1)在界面中创建
#      右击首行root@localhost，选择“创建数据库”, 输入数据库名， 维护编码格式，确定即可。
#   (2)使用SQL脚本语句创建
#      create database 数据名;
       CREATE DATABASE ABCDDataBase;
#   使用数据库
#      use 数据名;
       USE ABCDDataBase;
       
##5、创建表
#   (1)在界面中创建
#     右击tables，选择“创建表”
#     维护表结构[告知对象中的属性有那些]
#        数据库中的类型：
#            整数    INT
#            小数    FLOAT  DOUBLE
#            字符串  CHAR   VARCHAR   TEXT
#            布尔    BIT    BOOLEAN   --> 建议改为int的1和0表示
#            日期    DATE
#        输入表名
#    (2)使用SQL脚本语句创建
#        create table 表名
#        (
#            列名 类型  约束，
#            列名 类型  约束
#        )
    CREATE TABLE Teacher
    (
           teaNo INT(4),
           teaName VARCHAR(50),
           teaTime FLOAT,
           rzTime DATE
    )

#6、在表里维护数据
#   (1)在界面中维护
#      右击表名，选择“打开表”，双击维grade护数据
#   (2)使用SQL脚本语句新增数据
#      insert into 表名(列名,列名) values(值,值)
       INSERT INTO teacher(teaNo,teaName,teaTime,rzTime) VALUES(1,'zhangsan',10.5,'2013-01-01');

#结构化查询语言SQL语句的分类：
#【一】DDL语句[数据定义语言]
#      CREATE、DROP、ALTER
#【二】DCL语句[数据控制语言]
#      GRANT、REVOKE COMMIT、ROLLBACK
#【三】DML语句[数据操作语言]
#      INSERT、UPDATE、DELETE
#【四】DQL语句[数据查询语言]
#      SELECT

#【一】DDL语句[数据定义语言]
#一、create
# 1) 创建用户
#    create user '用户名'@'localhost' identified 密码
# 2) 创建数据库
#    create database 数据库名;
# 3) 创建表
#    create table 表名
#    (
#       列名 类型 约束
#    )
# 4）创建视图
#    create view 视图名
#    as
#       select语句
# 5）创建索引
#    create index 索引名 on 表名(列名)

#二、drop
# 1) 删除用户
DROP USER 'ABCD'@'localhost';
# 2) 删除数据库
DROP DATABASE ABCDdatabase;
# 3) 删除表
DROP TABLE student;
# 4) 删除表结构

#三、alter

#数据完整性约束：
# (1)实体完整性约束
#    作用：约束每一行数据[对象]都唯一
#    实现方式：主键、唯一键、自动增长[特指数值]
# (2)域完整性约束
#    作用：约束每一列的要求
#    实现方式：非空、类型、默认值   [mysql不支持检查约束]
# (3)引用完整性约束
#    作用：约束从表的数据必须关联的上主表数据
#    实现方式：主外键约束
#        区分主从表：“从表”属于“主表”
#        要求：主表必须有主键，主表的关联键和从表的外键类型一致
#              在从表中建
# (4)自定义完整性
#    作用：满足业务需求
#    实现方式：存储过程、触发器

#  [1]添加约束
#    1）创建表的同时创建约束
        #客户表   从表
    CREATE TABLE customer
    (
       custNo INT(4) PRIMARY KEY AUTO_INCREMENT NOT NULL,
       custName VARCHAR(50) UNIQUE KEY,
       custAddr VARCHAR(200) NULL DEFAULT '某城市'
       typeNo INT(4) NOT NULL,
       FOREIGN KEY(typeNo) REFERENCES customerType(custTypeNo) ,
           
    )
     /* 外键              关联          主表       关联键 */

    #客户类型表  主表
    CREATE TABLE customerType
    (
        custTypeNo INT(4) PRIMARY KEY,
        custTypeName VARCHAR(50) NOT NULL
    )
    
    CREATE TABLE student
    (
             stuNo INT(4) ,
             stuName VARCHAR(50),
             PRIMARY KEY(stuNo,stuName)
                 
    )
    
#    2) 创建表之后追加约束

    CREATE TABLE customer
    (
       custNo INT(4) ,
       custName VARCHAR(20),
       custTel VARCHAR(11) NOT NULL,
       custLevel INT(4) ,   
       custType INT(4) NOT NULL
    )
    
#    [主键、唯一键、默认值、主外键 是可以在建表之后追加约束]
#    [自动增长、非空、类型 只能在建表时创建]
#    基本语法：
#       Alter table 表名 add constraint 约束名 约束类型(列名)
#       主键：
    ALTER TABLE customer ADD CONSTRAINT PK_customer_custNo PRIMARY KEY(custNo)
#       唯一键：
    ALTER TABLE customer ADD CONSTRAINT UK_customer_custName UNIQUE KEY(custName)
#    默认值语法：
#    ALTER TABLE 表名 ALTER 列名 SET DEFAULT 默认值;
    ALTER TABLE customer ALTER custLevel SET DEFAULT 1;
#    主外键语法：
#       主外键：从表的外键关联主表的关联键
#       从表  属于 主表      从表多 对应 主表一
#       从表里的键叫外键  主表里的键叫关联键
#       主外键约束只能在从表里创建，要求主表必须有主键、外键和关联键的类型要一致
#    alter table 从表名 add constraint 约束名 FOREIGN KEY(外键列) REFERENCES 主表名(关联键)
     ALTER TABLE customer ADD CONSTRAINT FK_customer_customerType FOREIGN KEY(custType) REFERENCES customerType(custTypeNo)

# [2]删除约束
#ALTER TABLE 表名 DROP 约束类型;
#删主键约束
ALTER TABLE customer DROP PRIMARY KEY;
#删唯一键约束
ALTER TABLE customer DROP INDEX UK_customer_custName;
#删默认值
ALTER TABLE customer ALTER custLevel DROP DEFAULT;
#删除主外键
ALTER TABLE customer DROP FOREIGN KEY FK_customer_customerType;
#删除主外键的索引
ALTER TABLE customer DROP INDEX FK_customer_customerType;

# [3]更改表结构
# 修改表名
# ALTER TABLE 旧表名 RENAME AS 新表名
ALTER TABLE customer RENAME AS kehu;
# 添加字段
# ALTER TABLE 表名 ADD 列名 列类型 [约束]  
ALTER TABLE kehu ADD custInfo VARCHAR(50) NOT NULL;
# 修改字段
#    列类型  ALTER TABLE 表名 MODIFY 列名 列类型 [约束]   
ALTER TABLE kehu MODIFY custinfo CHAR(20) ;
#    列名称  ALTER TABLE 表名 CHANGE 旧列名 新列名 列类型
ALTER TABLE kehu CHANGE custinfo custdesc VARCHAR(50);
#删除字段
#ALTER TABLE 表名 DROP 列名
ALTER TABLE kehu DROP custdesc;

#【二】DCL语句[数据控制语言]
# GRANT、REVOKE COMMIT、ROLLBACK
#grant语句
# 授权功能：添加对表中数据的增删改查权限
# grant 权限 on 数据库名点表名 to 用户
GRANT INSERT,UPDATE,DELETE,SELECT ON ABCDdatabase.student TO ABCD

# 收回权限功能：收回对表中数据的增删改查权限
# REVOKE 权限 ON 数据库对象 FROM 用户
REVOKE INSERT,UPDATE,DELETE ON ABCDdatabase.student FROM ABCD

#做事务的：
#COMMIT语句
#  将数据永久保存到数据库中
#ROLLBACK语句
#  取消当前数据的持久化状态，回退到提交之前

#每一个SQL语句自成一个事务，所以执行单个sql语句也能立即执行保存到数据库

CREATE TABLE bank
(
   account VARCHAR(50),
   money INT
)
#update修改语句
UPDATE bank SET money=money-500 WHERE account='zhangsan';
UPDATE bank SET money=money+500 WHERE account='lisi';

#取消sql语句的自动提交[取消一个sql语句自成一个事务]
SET autocommit= 0;

#开启事务
START TRANSACTION;
UPDATE bank SET money=money-500 WHERE account='zhangsan';
UPDATE bank SET money=money+500 WHERE account='lisi';

#结束事务
#提交
COMMIT;
#回滚
ROLLBACK;

#sql语句的自动提交
SET autocommit= 1;

#【三】DML语句[数据操作语言]
#新增insert
#1）往已存在的表中插入一条写死数据
#  insert into 表名(列名,列名) values(值,值)
INSERT INTO bank(account,money) VALUES ('wangwu',800);
INSERT INTO bank(account) VALUES ('sunba');
INSERT INTO bank(account,sj) VALUES ('sunba','2023-1-1');
INSERT INTO bank(account,money,sj) VALUES ('sunba',DEFAULT,'2023-1-1');

#2）往已存在的表中插入多条数据
#  <1>插入多条写死数据
#     insert into 表名(列名,列名) values(值,值),(值,值)
INSERT INTO bank(account,money) VALUES ('zhaoliu',600),('tianqi',700);

#  <2>从已存在的表中获取数据插入到另一个已存在的表中
#     insert into 获得数据的表名(获取数据的列名)
#     select 提供数据的列名 from 提供数据的表名
INSERT INTO bank2(zh,ye)
SELECT account,money FROM bank

#  <3>往已存在的表中插入多条固定值
#     insert into 获得数据的表名(获取数据的列名)
#       select 值 union/union all
#       select 值   
#     union合并相同数据，union all不会  不支持default
INSERT INTO bank3(zhanghao,yue)
SELECT 'haha',500 UNION ALL
SELECT 'haha',500
#SELECT 'haha',default

#3）往不存在的表中插入多条数据
# create table 表名(select 提供数据列名 from 提供数据表名)
CREATE TABLE yinhang(SELECT account,money FROM bank)

#已知：数据库中存在student表[学号、姓名、年龄、年级外键]。
#实现：往学生表中插入一条语句。
#      往学生表中插入二条语句。
#      往学生临时表stuTemp[不存在]中插入学生表的所有数据。

#修改update
#语法：update 表名 set 列名=更新值,列名=更新值 where 布尔类型表达式
#条件为true才更新，为false不更新
#整表过滤更新[一行一行更新]
#where省略表示所有条件均为ture
# 且and  或or  非not
UPDATE yinhang SET money = 100, account='zs'WHERE account='zhangsan'
UPDATE yinhang SET money = 100 WHERE account='zhangsan'
UPDATE yinhang SET money = 300 WHERE account='lisi' OR money=100
UPDATE yinhang SET money = 100 WHERE NOT(money = 500)

#删除delete
#语法：delete from 表名 where 布尔类型表达式
#条件为true才删除，为false不删除
#整表过滤删除[一行一行删除]
#where省略表示所有条件均为ture
#注意：
#     删除数据都是删除横着的数据行，不能删除数据列
DELETE FROM bank WHERE account='tianqi'

 
#关系运算符：and  or  not
#            &&  ||   !

#删除truncate
#语法： truncate table 表名
#没有where条件，整表删除
#自动增长列会恢复从1开始
TRUNCATE TABLE kehu

#【四】DQL语句[数据查询语言]
#（1）基本查询语句
#（2）连接(多表)查询语句
#（3）联合查询语句
#（4）子查询语句

#查询语句的作用，将满足条件的数据以结果集的形式返回。
# 1、基本查询语句
#    从单表中取数据显示
#     语法：
#          select 列名，列名   显示数据
#          from 表名           从表中取数据
#          where 布尔条件      整表过滤数据
#          group by 分组列     对数据做分类
#          having 筛选条件     针对分组后的数据再做过滤
#          order by 排序列     对数据排序 asc升序 desc降序
#          limit  下标,记录数
#     注意：
#          每种关键字顺序不能改变，但可以缺失。就算缺失，先后顺序也不能改变
#          优先级 高-->低：from --> where --> group by --> having --> order by --> select
#          where控制行数，select控制列数

SELECT stuNo,stuName FROM student
SELECT stuNo,stuName FROM student WHERE stuNo = 1
SELECT stuNo,stuName FROM student ORDER BY stuNo DESC

#分组查询：对原表数据做分类，结果集的行数取决于分类的个数
#          显示的列要么出现在分组中，要么出现在聚合函数中
#          多列分组使用逗号隔开,写在前面的先分组，写在后面的后分组

#聚合函数：统计数据的函数。最终得到的是一行一列数据,不能和返回多行多列的数据共同使用
#          count(列) 个数
#          max(列)   最大值
#          min(列)   最小值
#          sum(列)   求和
#          avg(列)   平均值

SELECT stuName FROM student WHERE stuNo = 1

SELECT gradeId,COUNT(stuNo) FROM student GROUP BY gradeId
SELECT sex, gradeId,COUNT(stuNo) FROM student GROUP BY sex, gradeId

#统计每个年级人数
SELECT gradeId,COUNT(stuNo) FROM student GROUP BY gradeId
#统计最大年龄
SELECT MAX(stuAge) FROM student
#统计每个年级的学生的平均年龄
SELECT gradeId,AVG(stuAge) FROM student GROUP BY gradeId
#统计低年级的学生人数[12年级]
SELECT COUNT(1) FROM student WHERE gradeId < 3

#统计人数超过1个的年级
SELECT gradeId,COUNT(1) FROM student GROUP BY gradeId HAVING COUNT(1) >1

#查询最大年龄前两名
SELECT * FROM student ORDER BY stuAge DESC LIMIT 0,2

#2、连接(多表)查询语句
CREATE TABLE ta
(
  id INT(4) NOT NULL,
  `name` VARCHAR(20) NOT NULL
)

CREATE TABLE tb
(
  id INT(4) NOT NULL,
  `name` VARCHAR(20) NOT NULL
)
#   从多张表中取数据显示
#   [1]内连接 【取两个表的共有数据：在两个表中都具有的关联键，所对应的数据】
#      (1)语法：from A inner join B on A.关联键=B.关联键
SELECT * FROM ta INNER JOIN tb ON ta.id=tb.id
#      (2)语法：from A,B where A.关联键=B.关联键
SELECT * FROM ta,tb WHERE ta.id=tb.id

#学生表  学号  姓名
#成绩表  学号  成绩
#查询参加考试的学生信息[姓名、成绩]

#   [2]外连接
#      (1)左(外)连接  【以左表为主表，右表关联左表，左表的数据一定全显示，右表的数据能关联上就显示，关联不上不显示或空代替】
#       语法：from A left join B on A.关联键=B.关联键
SELECT * FROM ta LEFT JOIN tb ON ta.id=tb.id
#      (2)右(外)连接  【以由表为主表，左表关联右表，右表的数据一定全显示，左表的数据能关联上就显示，关联不上不显示或空代替】
#       语法：from A right join B on A.关联键=B.关联键
SELECT * FROM ta RIGHT JOIN tb ON ta.id=tb.id
SELECT * FROM tb LEFT JOIN ta ON ta.id=tb.id

#参加考试的学生信息
SELECT * FROM student LEFT JOIN score ON student.stuNo=score.stuId

#      (3)完全连接  【两个的数据都要显示，关联不上的以空代替】【Mysql不支持】
#       语法：from A full join B on A.关联键=B.关联键
SELECT * FROM ta FULL JOIN tb ON ta.id=tb.id
1   a1        2 b2
2   a2        3 b3
-------------------
1   a1        NULL NULL
2   a2        2  b2
NULL NULL     3  b3

#   [3]交叉连接   【一张表的每条数据都和另一张表的所有记录关联】
#       语法：from A cross join B    【没有on】
SELECT * FROM ta CROSS JOIN tb
#       非要加关联条件，只能在where里加。加完就变成内连接
SELECT * FROM ta CROSS JOIN tb WHERE ta.id=tb.id

#学生表：学号  姓名  年龄  年级编号
#年级表：编号  名称
#只显示学生姓名 和 年级名称

#语法：from A left join B on A.关联键=B.关联键
#学生表：学号  姓名  年龄  年级编号
#成绩表：编号  成绩  学生编号
SELECT studentName,studentResult
FROM student LEFT JOIN result ON student.studentNo=result.studentNo
WHERE studentresult IS NULL

SELECT * FROM ta
   INNER JOIN tb ON ta.id = tb.id
   INNER JOIN tc ON tc.id = ta.id/tb.id
   
SELECT * FROM ta,tb,tc WHERE ta.id = tb.id AND tc.id = ta.id/tb.id
      

#3、联合查询语句
#      合并结果集
#      语法： select 列 from A union / union all
#             select 列 from B
#      注意：多个结果集的列必须满足：个数、类型、顺序都一致才能合并
#            默认以第一个结果集的列名做为最终结果集列名
SELECT id,NAME FROM ta;
SELECT id,NAME FROM tb;

SELECT id,NAME FROM ta
UNION
SELECT id,NAME FROM tb;

SELECT gradeId,gradeName FROM grade
UNION ALL
SELECT id,NAME FROM tb;

#查询17岁以下学生
#查询17岁以上学生
#合并结果集

#4、子查询语句
#   当一个sql语句的数据由另一个查询语句提供,这个查询语句称为子查询
#   sql语句称为父查询
#   子查询必须用()括起来

#[1]使用场景一：子查询作为条件使用
#    语法：  父查询的 where 列 =/in (子查询)
#查询“一年级”的学生 / 低年级学生

#父查询：学生
#子查询是条件：一年级
#             将已知条件的名称转变为学生表能识别的年级编号
#             select gradeId from grade where gradeName = '一年级'
SELECT * FROM student WHERE gradeId = (SELECT gradeId FROM grade WHERE gradeName = '一年级')
SELECT * FROM student WHERE gradeId IN (SELECT gradeId FROM grade WHERE gradeName = '一年级' OR gradeName = '二年级')

#注意：
#     子查询相对父查询优先执行[因为子查询在()里]
#     要求子查询返回结果的个数必须和父查询的条件对应：= 后的子查询只能返回一个值
#                                                   子查询的结果不止一个值，父查询条件用in连接

# [2]使用场景二：子查询作为结果集使用
# 语法：  from (子查询) tn
# 注意：结果集的子查询必须加别名
#每个年级的人数
SELECT gradeId,COUNT(1) FROM student GROUP BY gradeId
#查询统计一年级的人数
SELECT gradeId,rs FROM (SELECT gradeId,COUNT(1) AS rs FROM student GROUP BY gradeId) AS tb WHERE gradeId != 1

# [3]使用场景三：子查询作为列使用
# 语法： select (子查询) as 列名 from 表
#查询学生信息(显示 学生学号、学生姓名、年级编号-> 年级名称 )
SELECT stuNo,stuName, gradeId FROM student
SELECT stuNo,stuName, (SELECT gradename FROM grade WHERE grade.gradeId=student.gradeId) mc FROM student

#注意：
#在mysql数据库中，
#   字符串和字符是不做区分的，只有单引号，没有双引号
#   关系(比较)运算符中的判断相等使用的是 = , 没有==

SELECT stuNo AS 学号 FROM student stu WHERE stuNo=2

#列起别名
#    真实列名 as 别名
#    真实列名 别名
#    表名 别名
#    表名 as 别名
#    子查询作为结果集必须起别名

#运算符
#赋值运算符/关系运算符比较相等  =
#算数运算符 +  -  *  /  %    【数据库里的+不在作为连接符用了，要求+两边的类型必须一致，都数值型才能运算】
#关系运算符 >  <  >=  <=  =  !=  <>
#逻辑运算符 and  or  not

#MySQL中的函数：
#1、字符串函数
#2、数学函数
#3、日期函数
#4、高级函数

#一、字符串函数
#★1）CHAR_LENGTH(s) 返回字符串 s 的字符数[长度]
SELECT CHAR_LENGTH("RUNOOB") AS LengthOfString;
#★2）CONCAT(s1,s2...sn)  多个字符串合并为一个字符串
SELECT CONCAT("SQL ", "Runoob ", "Gooogle ", "Facebook") AS ConcatenatedString;
#3）FIELD(s,s1,s2...) 返回第一个字符串 s 在字符串列表(s1,s2...)中的位置
SELECT FIELD("c", "a", "b", "c", "d", "e");
#4）FIND_IN_SET(s1,s2) 返回在字符串s2中与s1匹配的字符串的位置
SELECT FIND_IN_SET("c", "a,b,c");
#5）FORMAT(x,n) 格式化 "#,###.##", 将 x 保留到小数点后 n 位，最后一位四舍五入
SELECT FORMAT(250500.5684, 2);
#★6）INSERT(s1,x,len,s2)  字符串 s2 替换 s1 的 x 位置开始长度为 len 的字符串
SELECT INSERT("google.com", 1, 3, "runoob");
#7）LEFT(s,n) 返回字符串 s 的前 n 个字符
SELECT LEFT('runoob',2)
#8）RIGHT(s,n) 返回字符串 s 的后 n 个字符
SELECT RIGHT('runoob',2)
#★9）LOWER(s) 将字符串 s 的所有字母变成小写字母
SELECT LOWER('RUNOOB')
#★10）UPPER(s)   将字符串转换为大写
SELECT UPPER("runoob");
#11）LPAD(s1,len,s2) 在字符串 s1 的开始处填充字符串 s2，使字符串长度达到 len
SELECT LPAD('abc',2,'xx')
#12）RPAD(s1,len,s2) 在字符串 s1 的结尾处添加字符串 s2，使字符串的长度达到 len
SELECT RPAD('abc',5,'xx')
#13）LTRIM(s)  去掉字符串 s 开始处的空格
SELECT LTRIM("    RUNOOB    ") AS LeftTrimmedString;
#14）RTRIM(s)  去掉字符串 s 结尾处的空格
SELECT RTRIM("    RUNOOB    ") AS RightTrimmedString
#★15）TRIM(s)   去掉字符串 s 开始和结尾处的空格
SELECT TRIM("    RUNOOB    ") AS TrimmedString
#16）MID(s,n,len)  从字符串 s 的 n 位置截取长度为 len 的子字符串，同 SUBSTRING(s,n,len)
SELECT MID("RUNOOB", 2, 3) AS ExtractString;
#★17）POSITION(s1 IN s)   从字符串 s 中获取 s1 的开始位置
SELECT POSITION('b' IN 'abc')
#18）REPEAT(s,n)   将字符串 s 重复 n 次
SELECT REPEAT('runoob',3)
#★19）REPLACE(s,s1,s2) 将字符串 s2 替代字符串 s 中的字符串 s1
SELECT REPLACE('abc','a','x')
#20）REVERSE(s)   将字符串s的顺序反过来
SELECT REVERSE('abc')
#21）SPACE(n) 返回 n 个空格
SELECT SPACE(10)
#22）STRCMP(s1,s2)  比较字符串 s1 和 s2，如果 s1 与 s2 相等返回 0 ，如果 s1>s2 返回 1，如果 s1 SELECT STRCMP("a", "b");
#23）SUBSTR(s, start, length) 从字符串 s 的 start 位置截取长度为 length 的子字符串
SELECT SUBSTR("RUNOOB", 2, 3) AS ExtractString
#★24）SUBSTRING(s, start, length)  从字符串 s 的 start 位置截取长度为 length 的子字符串，等同于 SUBSTR(s, start, length)
SELECT SUBSTRING("RUNOOB", 2, 3) AS ExtractString
#25）SUBSTRING_INDEX(s, delimiter, number) 返回从字符串 s 的第 number 个出现的分隔符。
#                                          如果 number 是正数，返回第 number 个字符左边的字符串。
#                                          如果 number 是负数，返回第(number 的绝对值(从右边数))个字符右边的字符串。
SELECT SUBSTRING_INDEX('a*b*c*d*e','*',3)
SELECT SUBSTRING_INDEX(SUBSTRING_INDEX('a*b*c*d*e','*',3),'*',-1)

#二、数学函数
#★1）ABS(x) 返回 x 的绝对值
SELECT ABS(-1)
#★2）AVG(expression) 返回一个表达式的平均值，expression 是一个字段
SELECT AVG(gradeId) FROM student;
#★3）CEIL(x) 返回大于或等于 x 的最小整数
SELECT CEIL(1.1)
#★4）COUNT(expression) 返回查询的记录总数，expression 参数是一个字段或者 * 号
SELECT COUNT(stuage) AS NumberOfAge FROM student;
#5）EXP(x) 返回 e 的 x 次方
SELECT EXP(1)
#★6）FLOOR(x) 返回小于或等于 x 的最大整数
SELECT FLOOR(1.9)
#★7）MAX(expression)  返回字段 expression 中的最大值
SELECT MAX(gradeId) FROM student;
#★8）MIN(expression) 返回字段 expression 中的最小值
SELECT MIN(gradeId) FROM student;
#9）MOD(x,y)   返回 x 除以 y 以后的余数
SELECT MOD(5,2)
#10）PI() 返回圆周率(3.141593）
SELECT PI()
#11）POW/POWER(x,y)  返回 x 的 y 次方
SELECT POW(2,3)
#12）RAND()  返回 0 到 1 的随机数
SELECT RAND()
#13）SQRT(x)  返回x的平方根
SELECT SQRT(9)
#★14）SUM(expression) 返回指定字段的总和
SELECT SUM(gradeId) FROM student;
#15）TRUNCATE(x,y)  返回数值 x 保留到小数点后 y 位的值（不四舍五入）
SELECT TRUNCATE(1.23456,3)

#三、日期函数
#★1）ADDDATE(d,n)  计算起始日期 d 加上 n 天的日期
SELECT ADDDATE("2022-10-12", 20);
#2）ADDTIME(t,n)  在t时间上添加n表示式[时分秒]
SELECT ADDTIME("2022-10-12 15:17:41", "1:1:20");
#3）CURDATE()  返回当前年月日
SELECT CURDATE();
#4）CURRENT_DATE()  返回当前年月日
SELECT CURRENT_DATE()
#5）CURRENT_TIME()  返回当前时分秒
SELECT CURRENT_TIME();
#6）SELECT CURRENT_TIME() 返回当前年月日时分秒
SELECT CURRENT_TIMESTAMP()
#7）DATE()  从日期或日期时间表达式中提取日期值
SELECT DATE("2022-06-15")
#★8）DATEDIFF(d1,d2)  计算日期 d1->d2 之间相隔的天数
SELECT DATEDIFF('2022-03-02','2022-01-01')
#9）DATE_ADD(d，INTERVAL expr type)  计算起始日期 d 加上一个时间段后的日期 [时间类型可变]
SELECT DATE_ADD("2022-10-12", INTERVAL 10 DAY);    
SELECT DATE_ADD("2022-10-12", INTERVAL -3 MONTH);
SELECT DATE_ADD("2022-10-12", INTERVAL 1 YEAR);
#10）DATE_FORMAT(d,f)  按表达式 f的要求显示日期 d
SELECT DATE_FORMAT('2022-10-12 11:11:11','%Y-%m-%d %r')
#11）DATE_SUB(date,INTERVAL expr type) 从日期减去指定的时间间隔
SELECT DATE_SUB('2022-10-12',INTERVAL 2 DAY)
#12）DAY(d)  返回日期值 d 的日期部分
SELECT DAY("2022-10-12");
#13）DAYNAME(d) 返回日期 d 是星期几
SELECT DAYNAME('2022-10-12')
#14）DAYOFMONTH(d)  计算日期 d 是本月的第几天
SELECT DAYOFMONTH('2022-10-12')
#15）DAYOFWEEK(d)  日期 d 今天是星期几 1 星期日
SELECT DAYOFWEEK('2022-10-12')
#16）DAYOFYEAR(d) 计算日期 d 是本年的第几天
SELECT DAYOFYEAR('2022-10-12')
#17）HOUR(t)  返回 t 中的小时值
SELECT HOUR('2022-10-12 15:56:41')
#18）LAST_DAY(d)  给给定日期的那一月份的最后一天
SELECT LAST_DAY("2022-10-12");
#19）LOCALTIME()  返回当前日期和时间
SELECT LOCALTIME()
#20）LOCALTIMESTAMP() 返回当前日期和时间
SELECT LOCALTIMESTAMP()
#21）MINUTE(t)  返回 t 中的分钟值
SELECT MINUTE('2022-10-12 15:56:41')
#22）MONTHNAME(d)  返回日期当中的月份名称，如 November
SELECT MONTHNAME('2022-10-12 15:56:41')
#23）MONTH(d)  返回日期d中的月份值，1 到 12
SELECT MONTH('2022-10-12 15:56:41')
#24）NOW()  返回当前日期和时间
SELECT NOW()
#25）QUARTER(d) 返回日期d是第几季节，返回 1 到 4
SELECT QUARTER('2022-10-12 15:56:41')
#26） SECOND(t)  返回 t 中的秒钟值
SELECT SECOND('2022-10-12 15:56:41')
#27）SEC_TO_TIME(s) 将以秒为单位的时间 s 转换为时分秒的格式
SELECT SEC_TO_TIME(4321)
#28）STR_TO_DATE(string, format_mask) 将字符串转变为日期
SELECT STR_TO_DATE("August 10 2017", "%M %d %Y");
#29） SUBDATE(d,n) 日期 d 减去 n 天后的日期
SELECT SUBDATE('2022-10-12 15:56:41', 10)
#30）SUBTIME(t,n)  时间 t 减去 n 秒的时间
SELECT SUBTIME('2022-10-12 15:56:41', 5)
#31）SYSDATE()  返回当前日期和时间
SELECT SYSDATE()
#32） TIME(expression)  提取传入表达式的时间部分
SELECT TIME("19:30:10");
#33）TIME_TO_SEC(t) 将时间 t 转换为秒
SELECT TIME_TO_SEC('1:12:00')
#34）TIMEDIFF(time1, time2)  计算时间差值
SELECT TIMEDIFF("13:10:11", "13:10:10");
#35）TO_DAYS(d)  计算日期 d 距离 0000 年 1 月 1 日的天数
SELECT TO_DAYS('0001-01-01 01:01:01')
#36）WEEK(d) 计算日期 d 是本年的第几个星期，范围是 0 到 53
SELECT WEEK('2022-10-12')
#37）WEEKDAY(d)  日期 d 是星期几，0 表示星期一，1 表示星期二
SELECT WEEKDAY("2022-10-12");
#38） WEEKOFYEAR(d)  计算日期 d 是本年的第几个星期，范围是 0 到 53
SELECT WEEKOFYEAR('2022-10-12')
#39） YEAR(d)  返回年份
SELECT YEAR("2022-10-12");
#40）YEARWEEK(date, mode) 返回年份及第几周（0到53），mode 中 0 表示周天，1表示周一，以此类推
SELECT YEARWEEK("2022-10-12");

#四、高级函数
# IF(expr,v1,v2)如果表达式 expr 成立，返回结果 v1；否则，返回结果 v2
SELECT IF(100 > 10,'正确','错误')  
# CURRENT_USER()/SESSION_USER()/SYSTEM_USER()/USER()返回当前用户
SELECT CURRENT_USER()
# DATABASE()返回当前数据库名
SELECT DATABASE()
# VERSION()返回数据库的版本号
SELECT VERSION()

#分页查询
#limit 第一条记录的下标[下标从0开始]，显示记录数
#写在基本SQL语句的最后面[在order by 之后]
#每页显示五条，12条显示3页
#页码数pageNo  每页显示记录数pageSize
#  pageIndex = (pageNo-1)*pageSize
#  pageSize
# pageNo      1  2  3  4
# pageIndex   0  5  10 15
# 总结：limit (pageNo-1)*pageSize,  pageSize
#       在SQL语句中，limit 后面的数据必须是直接数据，不能计算。

#SELECT * FROM student LIMIT (1-1)*5,5  错误的
SELECT * FROM student LIMIT 5,5

#模糊查询
#like '%X%'   %表示匹配任意多个字符(支持0个)   _表示任意一个字符(不支持0个)
#     姓张的： stuName like '%张%'
SELECT * FROM student WHERE stuName LIKE '%s%'
SELECT * FROM student WHERE stuName LIKE 'z_'
#模糊查询实现：科目名称有“小”字的

#between 小值 and 大值   包含两端值，只要是连续的数据都可使用
SELECT * FROM customer WHERE custLevel BETWEEN 2 AND 8
SELECT * FROM customer WHERE custName BETWEEN 'b' AND 'w'
SELECT * FROM 表 WHERE 时间 BETWEEN '2022-10-01' AND '2022-10-12'

#in(x,x....) / not in()  在范围内匹配值，范围里的数据是精确值
SELECT * FROM student WHERE stuName IN ('z','z%')
#使用in模糊查询学生年龄是16和18岁的
#in会结合子查询实现：查询非类型一的客户信息
#（1）查询不是类型一的类型   select custTypeNo from customertype where custTypeName != 'lx1'
#（2）查询客户   
SELECT * FROM kehu WHERE custType IN (SELECT custTypeNo FROM customertype WHERE custTypeName != 'lx1')

#判断空
# （1）该列默认为空，你没维护
#       is null  /   is not null
SELECT * FROM grade WHERE gradeName IS NULL
# （2）该列允许为空，你删成空
#       = ''    /    != ''
SELECT * FROM grade WHERE gradeName = ''