mysql 查询的所有操作

Posted 2021-01-01 收起你的小情绪

数据查询语言DQL
基本查询
语法形式
　　select [all | distinct] 字段或表达式列表 [from子句] [where子句] [group by子句] [having子句] [order by子句] [limit子句]；

select avg(degree),cno from score where cno like "3%" group by cno having count(cno)>=5;

　　解释说明：
　　select语句，作用是从“数据源”中，找出（取出）一定的数据，并作为该语句的返回结果（数据集）
　　数据源：
　　通常，数据源就是“表”。但：
　　也可以没有数据源，而是使用“直接数据”（或函数执行结果）。

[all | distinct]
　　用于设定所select出来的数据是否允许出现重复行（完全相同的数据行）
　　all：允许出现——默认不写就是All（允许的）。
　　distinct：不允许出现——就是所谓的“消除重复行”。
from子句
　　就是指定数据的来源，其实就是“表”，可以是一个表名，也可以是多个表——多表查询了。

where子句
　　一个概念：where子句，相当于php或js中的if条件语句：其最终结果就是布尔值（true/false）
　　php：if($n % 4 == 0 && $n % 100 != 0 || $n % 400 == 0 ){}
　　则：
　　where true, where 1; where 1=1; 都表示true
　　where false, where 0; where 1<>1; 都表示false

where中可用的运算符：
　　算术运算符： + - * / %
　　比较运算符： > >= < <= =（等于） <>（不等于）
　　==（等于，mysql扩展），!=（不等于，mysql扩展）
　　逻辑运算符： and（与） or（或） not（非）

布尔值的判断方式：
　　布尔值：本质上，布尔值只是一位整数的“别名”，0表示false，非0表示true。
　　判断为true： XX is true
　　判断为fale： XX is false
　　XX应该是一个字段名，且其类型应该是一个整数。
　　实际应用中，布尔值判断很少用，因为可以直接使用数学大小。

空值的判断方式：
　　判断为null： XX is null
　　判断为非空： XX is not null
　　XX应该是一个字段名
between语法：
　　XX between 值1 and 值2；
　　含义：字段XX的值在值1和值2之间（含），相当于：XX >=值1 and XX<=值2；
in语法：XX in (1,2,3,4,5) XX not in ()
　　Xx = 1 or xx = 2 or xx =3...
　　XX in (值1，值2，.......)；
　　含义：XX等于其中所列出的任何一个值都算成立，相当于：
　　XX = 值1 or XX = 值2 or XX = 值2
　　注意：其中的值1通常是“直接值”，但也可以是后面要学习的“查询结果值”
like语法（模糊查找）：
　　语法形式：　ＸＸ　like ‘要查找字符’;
　　说明：
　　1，like语法（模糊查找）用于对字符类型的字段进行字符匹配查找
　　2，要查找的字符中，有2个特殊含义的字符：
　　2.1: % 其含义是：代表任意个数的任意字符
　　2.2: _ 其含义是：代表1个的任意字符
　　2.3：这里的字符，都是指现实中可见的一个“符号”，而不是字节。
　　3，实际应用中的模糊查找，通常都是这样：like ‘%关键字%’；

　　如果要查找的字符中包含“%”或“_”，“’”，则只要对他们进行转义就可以：
　　like ‘%ab\%cd%’ //这里要找的是： 包含 ab%cd 字符的字符
　　like ‘\_ab%’ //这里要找的是： _ab开头的字符
　　like ‘%ab’cd%’ //这里要找的是： 包含 ab’cd 字符的字符

　　where子句前面必须有from子句。虽然他们2者都可以省略，但有from可以没有where，而有where必须有from。

    select avg(degree),cno from score where cno like "3%" group by cno having count(cno)>=5;

 

group by 分组子句
　　形式：
　　group by 字段1 排序方式1，字段2 排序方式2， .....
　　通常都只进行一个字段的分组。
　　含义：
　　什么叫分组？就是将数据以某个字段的值为“依据”，分到不同的“组别”里。
　　分组的结果通常：
　　　　1，数据结果只能是“组”——没有数据本身的个体
　　　　2，数据结果就可能“丢失”很多特性，比如没有性别，身高，姓名，等等。
　　　　3，实际上，结果中通常只剩下“组”作为整体的信息：
　　　　首先是该组的本身依据值，
　　　　另外，这几个可能的值：组内成员的个数，组内某些字段的最大值，最小值，平均值，总和值。
　　　　其他字段，通常就不能用了。
　　　　4，如果是2个字段或以上分组，则其实是相当于对前一分组的组内，再进行后一依据的分组。
　　　　上述说明的结果，其实是反映在ｓｅｌｅｃｔ语句中，就是select的“取出项”（输出项）就基本只剩下以上信息了

　　　　在分组查询中，基本都依赖于一下几个函数（聚合函数，统计函数）：
　　　　count(*): 统计一组中的数量，通常用“*”做参数
　　　　max(字段名)：获取该字段中在该组中的最大值。
　　　　min(字段名)：获取该字段中在该组中的最小值。
　　　　sum(字段名)：获取该字段中在该组中的总和。
　　　　avg(字段名)：获取该字段中在该组中的平均值。
　　　　group_concat(字段名)：获取该分组内的这个字段所有信息，每条逗号分隔

    select avg(degree),cno from score where cno like "3%" group by cno having count(cno)>=5;

having子句
　　having子句其实概念跟where子句完全一样：
　　where是针对表的字段的值进行“条件判断”
　　having是只针对groupby之后的“组”数据进行条件判断，即
　　其不能使用：字段名>10
　　但可以使用：count(字段名)>10， 或 max(price) > 2000, 但如果字段是分组依据，也可以。
　　当然，通常也可以使用select中的有效的字段别名，比如：
　　select count(*) as f1 , max(f1) as f2 from tab1 group by f3 having f1 > 5 and f2 < 1000;

    select avg(degree),cno from score where cno like "3%" group by cno having count(cno)>=5;

Order by子句
　　形式：
　　order by 排序字段1 [排序方式]， 排序字段2 [排序方式]， .....
　　说明：
　　对前面取得的数据（含from子句，where子句，group子句，having子句的所有结果）来指定按某个字段的大小进行排列（排序），排序只有2种方式：
　　正序： ASC（默认值），可以省略
　　倒序： DESC
　　如果指定多个字段排序（虽然不常见），则其含义是，在前一个字段排序中相同的那些数据里，再按后一字段的大小进行指定的排序。
limit子句
　　形式：
　　limit [起始行号start]， 要取出的行数num
　　说明：
　　表示将前面取得的数据并前面排好之后（如果有），对之指定取得“局部连续的若干条”数据。
　　起始行号ｓｔａｒｔ：第一行的行号为０，　可以省略，则为默认行号（０）。
　　要取得的行数：如果结果集中从指定的行号开始到最后没有这么多行，则就只取到最后。

　　此子句非常有用——主要用于网页上最常见的一个需求（现象）：分页。
分页原理：
　　分页的前提：人为指定每页显示的条数，$pageSize = 3;
　　显示（取得）第1页数据：select * from 表名 limit 0, $pageSize;
　　显示（取得）第2页数据：select * from 表名 limit 3, $pageSize;
　　显示（取得）第3页数据：select * from 表名 limit 6, $pageSize;
　　..................................................
　　显示（取得）第$n页数据：select * from 表名 limit ($n-1)*$pageSize, $pageSize;
连接查询
　　基本含义
　　连接就是指两个或2个以上的表（数据源）“连接起来成为一个数据源”。
　　实际上，两个表的完全的连接是这样的一个过程：
　　左边的表的每一行，跟右边的表的每一行，两两互相“横向对接”后所得到的所有数据行的结果。
　　注意：连接之后，并非形成了一个新的数据表，而只是一种“内存形态”。
　　连接语法的基本形式
　　from 表1 [连接方式] join 表2 [on 连接条件]；
　　连接的结果可以当作一个“表”来使用。常用有以下几种连接方式：
　　交叉连接：
　　　　实际上，交叉连接是将两个表不设定任何条件的连接结果。
　　　　交叉连接通常也被叫做“笛卡尔积”——数学上可能比较多。
　　　　语法：
　　　　from 表1 join 表2 ; //可见交叉连接只是没有on条件而已。
　　内连接：
　　　　语法：
　　　　from 表1 join 表2 on 表1.字段1=表2.字段2；
　　　　含义：找出（过滤）在交叉连接的结果表中的表1的字段1的值等于表2的字段2的值的那些行。

　select sno,cname,degree from score join course on score.cno=course.cno;

　　左［外］连接：
　　　　形式：
　　　　from 表1 left [outer] join 表2 on 连接条件。

　　　　说明：
　　　　1，这里，left是关键字。
　　　　2，连接条件跟内连接一样。
　　　　3，含义是：内连接的结果基础上，加上左边表中所有不符合连接条件的数据，相应本应放右边表的字段的位置就自动补为“null”值。
　　右［外］连接：
　　　　右连接跟左连接恰恰相反：
　　　　形式：
　　　　from 表1 right [outer] join 表2 on 连接条件。
　　　　说明：
　　　　1，这里，right是关键字。
　　　　2，连接条件跟内连接一样。
　　　　3，含义是：在内连接的结果基础上，加上右边表中所有不符合连接条件的数据，相应本应放左边表的字段的位置就自动补为“null”值。
　　全［外］连接：
　　　　形式：
　　　　from 表1 full [outer] join 表2 on 连接条件；
　　　　说明：
　　　　1，含义：其实是左右连接的“并集”（消除重复项），即内连接的结果，加上左表中不满足条件的所有行（右边对应补null），再加上，

　　　　右表中不满足条件的所有行（左边对应补null）。
　　　　2，mysql中其实不认识全[外]连接语法，即mysql这个软件本身不支持全连接的语法。
　　　　3，此概念在其他数据库有的存在，了解就可以。
子查询
　　　　什么叫子查询
　　　　一个查询，通常就是一个select语句（即出现一次select关键字）
　　　　但，如果在一个select查询语句中，又出现了select查询语句，此时就称后者为“子查询”，前者就是“主查询”
　　　　形式：
　　　　selelct 字段或表达式或(子查询1) [as 别名] from 表名或(子查询2) where 字段或表达式或(子查询3) 的条件判断

select avg(degree) from Score where Sno in (select sno from student where class=‘95033‘);

　　　　注意：
　　　　每个位置所放置的子查询结果，应该符合该位置的数据需求。
　　　　通常：
　　　　子查询1应该是一个“数据结果”。
　　　　子查询2可以是“任意结果”，此位置的查询结果，通常作为数据源，可以给一个别名
　　　　子查询3可以是一个数据或一列数据甚至是一行数据

　　　　子查询按结果分类：
　　　　　　表子查询 ： 一个子查询返回的结果理论上是“多行多列”的时候。此时可以当做一个“表”来使用，通常是放在from后面。
　　　　　　行字查询 ： 一个子查询返回的结果理论上是“一行多列”的时候。此时可以当做一个“行”来使用，通常放在“行比较语法”中。
　　　　　　列子查询 ： 一个子查询返回的结果理论上是“多行一列”的时候。此时可以当做“多个值”使用，类似这种：(5, 17, 8, 22)。
　　　　　　标量子查询：一个子查询返回的结果理论上是“一行一列”的时候。此时可以当做“一个值”使用，类似这种：select 5 as c1; 或select ...where a = 17，或select ... where b 　　　　　　> 8;
　　　　按使用场合分：
　　　　　　作为主查询的结果数据：select c1,(select f1 from tab2) as f11 from tab1; #这里子查询应该只有一个数据（一行一列，标量子查询）
　　　　　　作为主查询的条件数据：select c1 from tab1 where c1 in (select f1 from tab2); #这里子查询可以是多个数据（多行一列，

　　　　　　列子查询，以及标量子查询，实际上行子查询也可能，但极少）
　　　　　　作为主查询的来源数据：select c1 from (select f1 as c1, f2 from tab2) as t2; #这里子查询可以是任意查询结果（表子查询）。

　　　　　　常见子查询及相关关键字
　　　　　　比较运算符中使用子查询
　　　　　　形式为： 操作数 比较运算符 (标量子查询)；
　　　　　　操作数通常是一个字段。
　　　　　　含义：判断该操作数（字段）的值是否满足该比较运算符所设定的比较结果。
　　　　　　其实就是相当于最简单的这种形式：　id > 5;
　　　　　　举例：
　　　　　　数据源：

　　　　　　需求：找出所有大于平均价的商品。
　　　　　　第一步：找平均价：
　　　　　　select avg(price) as avg_price from product;

　　　　　　第二部：找商品：
　　　　　　select * from product where price > 4287.7; ==〉
　　　　　　select * from product where price 〉（select avg(price) as avg_price from product）；

　　使用in子查询
　　　　in的基本语法形式为：
　　　　where 操作数 in (值1，值2， ....）
　　　　则in子查询就是：
　　　　where 操作数 in ( 列子查询 ）；
　　　　含义：
　　　　表示该操作数（字段值） 等于 该子查询的其中任意一个只，就算满足条件。

　　　　举例：
　　　　找出所有带“电”字的类别的产品
　　　　第一步：找出所有带“电”字的类别ID：

　　　　第二步：根据结果找出这些类别的产品：
　　　　select * from product where protype_id in (1, 3); ==〉
　　　　select * from product where protype_id in (
　　　　select protype_id from product_type where protype_name like ‘%电%‘
　　　　);

　　使用any子查询
　　　　使用形式：
　　　　where 操作数 比较运算符 any ( 列子查询 );
　　　　说明：
　　　　１操作数通常仍然是字段名
　　　　２比较运算符就是常规的〉　　〉＝　　＜　　　＜＝　　＝　　　＜＞　
　　　　３列子查询也可以是标量子查询，都表示“若干个数据值”
　　　　含义：
　　　　表示该操作数的值只要跟列子查询的任意一个值满足给定的比较运算，就算满足了条件——就是只要有一个成就成。
　　　　考察一个特定情况：
　　　　where 操作数 = any ( 列子查询 );
　　　　则其完全相当于：
　　where 操作数 in ( 列子查询 );
　　　　举例：
　　　　找出所有带“电”字的类别的产品

　　　　使用ａｌｌ子查询
　　　　where 操作数 比较运算符 all ( 列子查询 );
　　　　说明：
　　　　１操作数通常仍然是字段名
　　　　２比较运算符就是常规的〉　　〉＝　　＜　　　＜＝　　＝　　　＜＞　
　　　　３列子查询也可以是标量子查询，都表示“若干个数据值”
　　　　含义：
　　　　表示该操作数的值必须跟列子查询的所有值都满足给定的比较运算，才算满足了条件。

　　　　举例：
　　　　找出产品表中的价格最高的产品。
　　　　分析：最高价的产品的价格会大于等于所有产品价格。
　　　　select * from product where price >= all(
　　　　select price from product
　　　　);

　　　　方法二：
　　　　select * from product where price = (
　　　　select max(price) from product
　　　　);

　　使用some的子查询
　　　　some是any的同义词。一样用。
　　　　使用exists的子查询
　　　　以前所学：
　　　　if exist
　　　　或者：
　　　　if not exists
　　　　以前其含义通常是：存在某数据（通常是一个表）

　　　　现在，该词也同样用于子查询，表示同样的含义“存在”

　　　　形式：
　　where exists （子查询);
　　　　含义：
　　　　如果该子查询有结果数据（无论什么数据，只要大于等于１行），则就是true，否则为false

　　　　举例：
　　　　找出具有在售商品的那些类别：
　　　　select * from product_type where exists(
　　　　select * from product where product.protype_id=product_type.protype_id
　　　　);

　　使用not exists子查询
　　　　含义跟exists子查询相反。
　　　　举例：
　　　　找出还没有在售商品的类别：
　　　　select * from product_type where not exists(
　　　　select * from product where product.protype_id=product_type.protype_id
　　　　);

　　　　了解一下：实际上，这种exists（或not exists）子查询，如果涉及到2个表（或以上），其内部其实会自动进行“连接查询”，且

　　　　其逻辑过程较为负责，而且还不明确，通常认为属于效率较低的子查询，尽量少用。

　　联合查询
　　　　联合查询的关键字是： union
　　　　连接查询的关键字是： join
　　　　但，在mysql手册中， join这个连接查询，往往都翻译为“联合查询”
　　　　但在绝大多数的中文书籍和文章中，join被翻译为“连接查询”

　　　　基本含义
　　　　联合查询就是将两个select语句的查询结果“层叠”到一起成为一个“大结果”。
　　　　两个查询结果的能够进行“联合”的先觉条件是：结果字段数相等。

　　　　语法形式：
　　　　select 语句1
　　　　union [ALL | DISTINCT]
　　　　select 语句2；
　　　　说明：
　　　　1，两个select语句的输出段（结果字段）一样数目一样，应用中通常类型一样才有意义。
　　　　2，结果集中的字段以第一个select语句的字段为准。
　　　　3，第一个select语句的字段可以做别名，但如果做别名，则后续的where，group，order等子句应该用该别名。
　　　　4，联合查询默认是会消除重复项的（DISTINCT），要想不消除，则必须明确些“ALL”。
　　　　5，如果要对整个联合结果进行排序或limit，则应该对各自的select语句加括号：
　　　　（select 语句1）
　　　　union
　　　　（select 语句2）
　　　　order by ..... limit ....；