#数据库：数据的仓库。
#数据库类型划分：
# 关系型数据库：
# 每行数据代表一个对象信息，每列表示该对象的不同属性。
# 非关系型数据库：
# 以键值对方式存储数据
#数据库的专业术语：
# 以关系型数据库为例：
# 数据库系统 > 数据库管理系统 > 数据库 > 表 > 数据
#常用的关系型数据库：
# 后台使用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<s2 返回 -1
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 = ''
1664
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
