数据库mysql的基本操作

1.1 如何进入mysql? mysql的基本操作命令

//先进入mysql文件所在的bin目录下
cd C:\mysql-5.7.15-winx64\bin//进入mysql
mysql -uroot -p123456

//列出所有数据库名
show database;//使用、进入一个数据库
use 数据库名；//查看所有的表
show tables;//退出mysql
exit;//创建一个数据库
create database 数据库名;//导入表 注意：路径不能有中文
source D:\mysql_ceshi\表名.sqlsource C:\coursedb.sql
//查询dept表中的所有数据
select * from dept;//查询emp表中的所有数据
select * from emp;//查询emp表的关键信息
describe emp;
缩写：
desc emp;//查询dept表的关键信息
describe dept;
缩写：
desc dept;

//查看当前数据库版本
mysql> select version();//查看当前使用的是哪个数据库
mysql> select database();//删除数据库（表）
第一步，先退出
exit;
第二步，再进入
mysql -uroot -p123456
第三步，列出所有数据库（表）
show databases;、
第四步，选择要删除的库（表）
drop database 数据库名（或表名）;

1.2 简单查询

--进入mysqlmysql -uroot -p123456--创建新数据库create database ceshiku;--进入新创建的数据库use ceshiku;--导入新表source D:\mysql_ceshi\ceshibiao.sql--列出当前数据库的所有表名show tables;显示：+-------------------+
| Tables_in_ceshiku |
+-------------------+
| dept              |
| emp               |
+-------------------+--查询全部数据select * from emp;显示：+-------+--------+-----------+------+------------+---------+---------+--------+
| empno | ename  | job       | mgr  | hiredate   | sal     | comm    | deptno |
+-------+--------+-----------+------+------------+---------+---------+--------+
|  7369 | SMITH  | CLERK     | 7902 | 1980-12-17 |  800.00 |    NULL |     20 |
|  7499 | ALLEN  | SALESMAN  | 7698 | 1981-02-20 | 1600.00 |  300.00 |     30 |
|  7521 | WARD   | SALESMAN  | 7698 | 1981-02-22 | 1250.00 |  500.00 |     30 |
|  7566 | JONES  | MANAGER   | 7839 | 1981-04-02 | 2975.00 |    NULL |     20 |
|  7654 | MARTIN | SALESMAN  | 7698 | 1981-09-28 | 1250.00 | 1400.00 |     30 |
|  7698 | BLAKE  | MANAGER   | 7839 | 1981-05-01 | 2850.00 |    NULL |     30 |
|  7782 | CLARK  | MANAGER   | 7839 | 1981-06-09 | 2450.00 |    NULL |     10 |
|  7788 | SCOTT  | ANALYST   | 7566 | 1987-04-19 | 3000.00 |    NULL |     20 |
|  7839 | KING   | PRESIDENT | NULL | 1981-11-17 | 5000.00 |    NULL |     10 |
|  7844 | TURNER | SALESMAN  | 7698 | 1981-09-08 | 1500.00 |    0.00 |     30 |
|  7876 | ADAMS  | CLERK     | 7788 | 1987-05-23 | 1100.00 |    NULL |     20 |
|  7900 | JAMES  | CLERK     | 7698 | 1981-12-03 |  950.00 |    NULL |     30 |
|  7902 | FORD   | ANALYST   | 7566 | 1981-12-03 | 3000.00 |    NULL |     20 |
|  7934 | MILLER | CLERK     | 7782 | 1982-01-23 | 1300.00 |    NULL |     10 |
+-------+--------+-----------+------+------------+---------+---------+--------+--查询某个表的某个字段（单个信息）select 字段 from 表名;--查询emp表的empno字段的信息mysql> select empno from emp;显示：+-------+
| empno |
+-------+
|  7369 |
|  7499 |
|  7521 |
|  7566 |
|  7654 |
|  7698 |
|  7782 |
|  7788 |
|  7839 |
|  7844 |
|  7876 |
|  7900 |
|  7902 |
|  7934 |
+-------+--查询某个表的某些字段（多个信息）select 字段名,字段名,字段名,字段名 from 表名;--查询emp表的empno,ename,job,mg字段的信息select empno,ename,job,mgr from emp;显示：+-------+--------+-----------+------+
| empno | ename  | job       | mgr  |
+-------+--------+-----------+------+
|  7369 | SMITH  | CLERK     | 7902 |
|  7499 | ALLEN  | SALESMAN  | 7698 |
|  7521 | WARD   | SALESMAN  | 7698 |
|  7566 | JONES  | MANAGER   | 7839 |
|  7654 | MARTIN | SALESMAN  | 7698 |
|  7698 | BLAKE  | MANAGER   | 7839 |
|  7782 | CLARK  | MANAGER   | 7839 |
|  7788 | SCOTT  | ANALYST   | 7566 |
|  7839 | KING   | PRESIDENT | NULL |
|  7844 | TURNER | SALESMAN  | 7698 |
|  7876 | ADAMS  | CLERK     | 7788 |
|  7900 | JAMES  | CLERK     | 7698 |
|  7902 | FORD   | ANALYST   | 7566 |
|  7934 | MILLER | CLERK     | 7782 |
+-------+--------+-----------+------+

1.3 起别名

--给字段起别名，并查询该字段的内容（as可省略）select 字段名 as 别名 from emp;--给ename字段起别名为empname，并查询ename字段的内容select ename as empname from emp;--别名中含有空格，需要用单引号扩起来select ename as 'emp ename' from emp;显示：+-----------+
| emp ename |
+-----------+
| SMITH     |
| ALLEN     |
| WARD      |
| JONES     |
| MARTIN    |
| BLAKE     |
| CLARK     |
| SCOTT     |
| KING      |
| TURNER    |
| ADAMS     |
| JAMES     |
| FORD      |
| MILLER    |
+-----------+--给多个字段同时起别名，并查询这些字段的内容（使用逗号隔开即可）select job as 'emp job',empno as 'emp empno' from emp;显示：+-----------+-----------+
| emp job   | emp empno |
+-----------+-----------+
| CLERK     |      7369 |
| SALESMAN  |      7499 |
| SALESMAN  |      7521 |
| MANAGER   |      7566 |
| SALESMAN  |      7654 |
| MANAGER   |      7698 |
| MANAGER   |      7782 |
| ANALYST   |      7788 |
| PRESIDENT |      7839 |
| SALESMAN  |      7844 |
| CLERK     |      7876 |
| CLERK     |      7900 |
| ANALYST   |      7902 |
| CLERK     |      7934 |
+-----------+-----------+

1.4 字段计算

--对emp表的sal（月薪）字段进行计算，得到员工的年薪，并对年薪起别名为year salselect sal*12 as 'year sal' from emp;显示：+----------+
| year sal |
+----------+
|  9600.00 |
| 19200.00 |
| 15000.00 |
| 35700.00 |
| 15000.00 |
| 34200.00 |
| 29400.00 |
| 36000.00 |
| 60000.00 |
| 18000.00 |
| 13200.00 |
| 11400.00 |
| 36000.00 |
| 15600.00 |
+----------+--可以把‘year sal’改为中文的“年薪”select sal*12 as 年薪 from emp;

1.5 条件查询大于小于

--列出某个表的字段1，字段2，字段3；条件是 字段3>99999select 字段1,字段2,字段3 from 某表表名 where 字段3>99999;--查询月薪大于等于1000的员工，并列出员工号，员工姓名，月薪select empno,ename,sal from emp where sal>=1000;显示：+-------+--------+---------+
| empno | ename  | sal     |
+-------+--------+---------+
|  7499 | ALLEN  | 1600.00 |
|  7521 | WARD   | 1250.00 |
|  7566 | JONES  | 2975.00 |
|  7654 | MARTIN | 1250.00 |
|  7698 | BLAKE  | 2850.00 |
|  7782 | CLARK  | 2450.00 |
|  7788 | SCOTT  | 3000.00 |
|  7839 | KING   | 5000.00 |
|  7844 | TURNER | 1500.00 |
|  7876 | ADAMS  | 1100.00 |
|  7902 | FORD   | 3000.00 |
|  7934 | MILLER | 1300.00 |
+-------+--------+---------+--查询月薪在800到1000的员工，并列出员工号，员工姓名，月薪
方法一（字段3>=800 and 字段3<=800）：select empno,ename,sal from emp where sal>=800 and sal<=1000;方法二（字段3 between 800 and 1000）：mysql> select empno,ename,sal from emp where sal between 800 and 1000;
显示：+-------+-------+--------+
| empno | ename | sal    |
+-------+-------+--------+
|  7369 | SMITH | 800.00 |
|  7900 | JAMES | 950.00 |
+-------+-------+--------+

1.6 is null （注意：null在数据库中与在Java语言中是不同的，不能直接用=）

--查询所有没有津贴的员工（也就是comm值为null），并列出员工号，员工姓名，月薪select empno,ename,sal from emp where comm is null;--查询所有有津贴的员工（也就是comm值不为null），并列出员工号，员工姓名，月薪select empno,ename,sal from emp where comm is not null;--错误范例select empno,ename,sal from emp where comm=null;原因：null在数据库中与在Java语言中是不同的，不能直接用等号判断！

1.7 or （注意：and前后要是两个不同字段才能使用，若是同字段要使用or）

--查询中包含多个条件（where……and……）--查询职位是manager，月薪大于1000的员工，并列出员工号，员工姓名，月薪select empno,ename,sal from emp where job='manager' and sal>1000;--查询职位是manager和clerk的员工，并列出员工号，员工姓名，月薪select empno,ename,sal from emp where job='manager' or job='clerk';--查询职位是manager和clerk，月薪大于1000的员工，并列出员工号，员工姓名，月薪，职位select empno,ename,sal,job from emp where job='manager' or job='clerk' and sal>1000;显示：+-------+--------+---------+---------+
| empno | ename  | sal     | job     |
+-------+--------+---------+---------+
|  7566 | JONES  | 2975.00 | MANAGER |
|  7698 | BLAKE  | 2850.00 | MANAGER |
|  7782 | CLARK  | 2450.00 | MANAGER |
|  7876 | ADAMS  | 1100.00 | CLERK   |
|  7934 | MILLER | 1300.00 | CLERK   |
+-------+--------+---------+---------+--错误范例select empno,ename,sal from emp where job='manager' and job='clerk';原因：and前后要是两个不同字段才能使用，若是同字段要使用or！

1.8 and优先级高于or（系统会先执行用and连接的条件，再执行or后的条件）

--查询出部门10与部门20的经理，并列出两位经理的所有信息（deptno是部门编码的意思）select * from emp where (deptno=10 or deptno=20) and job='manager';显示：+-------+-------+---------+------+------------+---------+------+--------+
| empno | ename | job     | mgr  | hiredate   | sal     | comm | deptno |
+-------+-------+---------+------+------------+---------+------+--------+
|  7566 | JONES | MANAGER | 7839 | 1981-04-02 | 2975.00 | NULL |     20 |
|  7782 | CLARK | MANAGER | 7839 | 1981-06-09 | 2450.00 | NULL |     10 |
+-------+-------+---------+------+------------+---------+------+--------+--错误范例一：select * from emp where job='manager' and deptno=10 or deptno=20;显示：+-------+-------+---------+------+------------+---------+------+--------+
| empno | ename | job     | mgr  | hiredate   | sal     | comm | deptno |
+-------+-------+---------+------+------------+---------+------+--------+
|  7369 | SMITH | CLERK   | 7902 | 1980-12-17 |  800.00 | NULL |     20 |
|  7566 | JONES | MANAGER | 7839 | 1981-04-02 | 2975.00 | NULL |     20 |
|  7782 | CLARK | MANAGER | 7839 | 1981-06-09 | 2450.00 | NULL |     10 |
|  7788 | SCOTT | ANALYST | 7566 | 1987-04-19 | 3000.00 | NULL |     20 |
|  7876 | ADAMS | CLERK   | 7788 | 1987-05-23 | 1100.00 | NULL |     20 |
|  7902 | FORD  | ANALYST | 7566 | 1981-12-03 | 3000.00 | NULL |     20 |
+-------+-------+---------+------+------------+---------+------+--------+
原因：and优先级高于or，系统会先执行完job='manager' and deptno=10，再执行or deptno=20！
其含义是：查询出部门10的经理信息，和查询出部门20所有员工的信息！--错误范例二：select * from emp where deptno=10 or deptno=20 and job='manager';其含义是：查询出部门20的经理信息，和查询出部门10所有员工的信息！--错误范例三：select * from emp where deptno=10 and deptno=20 or job='manager';显示：+-------+-------+---------+------+------------+---------+------+--------+
| empno | ename | job     | mgr  | hiredate   | sal     | comm | deptno |
+-------+-------+---------+------+------------+---------+------+--------+
|  7566 | JONES | MANAGER | 7839 | 1981-04-02 | 2975.00 | NULL |     20 |
|  7698 | BLAKE | MANAGER | 7839 | 1981-05-01 | 2850.00 | NULL |     30 |
|  7782 | CLARK | MANAGER | 7839 | 1981-06-09 | 2450.00 | NULL |     10 |
+-------+-------+---------+------+------------+---------+------+--------+原因：and前后必须是两个不同字段，系统会直接忽视deptno=10 and deptno=20，只执行job='manager'其含义是：查询出所有的经理信息！

1.9 in

--查询某表中，某字段值为9999的所有有关信息select * from 某表表名 where 某字段名 in(9999);--查询出部门10所有员工的信息select * from emp where deptno in(10);等效于：select * from emp where deptno=10;显示：+-------+--------+-----------+------+------------+---------+------+--------+
| empno | ename  | job       | mgr  | hiredate   | sal     | comm | deptno |
+-------+--------+-----------+------+------------+---------+------+--------+
|  7782 | CLARK  | MANAGER   | 7839 | 1981-06-09 | 2450.00 | NULL |     10 |
|  7839 | KING   | PRESIDENT | NULL | 1981-11-17 | 5000.00 | NULL |     10 |
|  7934 | MILLER | CLERK     | 7782 | 1982-01-23 | 1300.00 | NULL |     10 |
+-------+--------+-----------+------+------------+---------+------+--------+--查询某表中，某字段值为10或20或30的所有有关信息select * from 某表表名 where 某字段名 in(10,20,30);--查询出部门10与部门20的所有员工信息select * from emp where deptno in(10,20);显示：+-------+--------+-----------+------+------------+---------+------+--------+
| empno | ename  | job       | mgr  | hiredate   | sal     | comm | deptno |
+-------+--------+-----------+------+------------+---------+------+--------+
|  7369 | SMITH  | CLERK     | 7902 | 1980-12-17 |  800.00 | NULL |     20 |
|  7566 | JONES  | MANAGER   | 7839 | 1981-04-02 | 2975.00 | NULL |     20 |
|  7782 | CLARK  | MANAGER   | 7839 | 1981-06-09 | 2450.00 | NULL |     10 |
|  7788 | SCOTT  | ANALYST   | 7566 | 1987-04-19 | 3000.00 | NULL |     20 |
|  7839 | KING   | PRESIDENT | NULL | 1981-11-17 | 5000.00 | NULL |     10 |
|  7876 | ADAMS  | CLERK     | 7788 | 1987-05-23 | 1100.00 | NULL |     20 |
|  7902 | FORD   | ANALYST   | 7566 | 1981-12-03 | 3000.00 | NULL |     20 |
|  7934 | MILLER | CLERK     | 7782 | 1982-01-23 | 1300.00 | NULL |     10 |
+-------+--------+-----------+------+------------+---------+------+--------+

1.10 not in

--查询除了部门20与部门10的其他员工信息select * from emp where deptno not in(20,30);显示：+-------+--------+-----------+------+------------+---------+------+--------+
| empno | ename  | job       | mgr  | hiredate   | sal     | comm | deptno |
+-------+--------+-----------+------+------------+---------+------+--------+
|  7782 | CLARK  | MANAGER   | 7839 | 1981-06-09 | 2450.00 | NULL |     10 |
|  7839 | KING   | PRESIDENT | NULL | 1981-11-17 | 5000.00 | NULL |     10 |
|  7934 | MILLER | CLERK     | 7782 | 1982-01-23 | 1300.00 | NULL |     10 |
+-------+--------+-----------+------+------------+---------+------+--------+

1.11 模糊查询（like），以及正则表达式模糊查询（binary）

--查询姓名中包含'L'的员工（‘%’表示若干个字符） select ename from emp where ename like '%L%';--查询姓名中第一个字母为'L'的员工 select ename from emp where ename like 'L%';--查询姓名中最后一个字母为'L'的员工  select ename from emp where ename like '%L';--查询姓名中第二个字母为'L'的员工（此时第一个未知字母可以用'_'表示）select ename from emp where ename like '_L%';--查询姓名中第二个字母为'L'的员工（前面有几个未知字母就用几个'_'表示）select ename from emp where ename like '__L%';--查询姓名中包含下划线的员工select ename from emp where ename like '%\_%';--错误范例：select ename from emp where ename like '%_%';原因：'_'具有特殊含义，若要查询它，需用到转移字符'\' --escape自定义转义符在使用LIKE关键字进行模糊查询时，“%”、“_”和“[]”单独出现时，会被认为是通配符。为了在字符数据类型的列中查询是否存在百分号 （%）、下划线（_）或者方括号（[]）字符，就需要有一种方法告诉DBMS，将LIKE判式中的这些字符看作是实际值，而不是通配符。关键字 ESCAPE允许确定一个转义字符，告诉DBMS紧跟在转义字符之后的字符看作是实际值。如下面的表达式：LIKE '%M%' ESCAPE ‘M'使用ESCAPE关键字定义了转义字符“M”，告诉DBMS将搜索字符串“%M%”中的第二个百分符（%）作为实际值，而不是通配符。当然，第一个百分符（%）仍然被看作是通配符，因此满足该查询条件的字符串为所有以％结尾的字符串。----使用escape自定义转义符，查询姓名中包含下划线的员工select ename from emp where ename like '%&_%' escape '&';

--正则表达式 regexp正则表达式的模式匹配功能比like运算符的模式匹配功能更为强大，且更加灵活。使用正则表达式进行模糊查询的语法格式如下：字段名 [not] regexp [binary] '正则表达式';--提示：匹配时默认不区分大小写，除非使用bianry选项或者设置字符序为bin或者cs.--例题1：使用正则表达式，检索家庭地址中含有“福建”的学生信息。select * from students where address regexp '福建';等效于：select * from students where address like '%福建%';--例题2：使用正则表达式，检索课程名以“程序设计”结尾的课程信息。select * from course where c_name regexp '程序设计$';等效于：select * from course where c_name like '%程序设计';--例题3：使用正则表达式，检索家庭地址以“福建”开头，并且以“区”结尾的学生信息。select * from students where address regexp '^福建.*区$';--例题4：使用正则表达式，检索学生联系方式中以15开头或者18开头，且后面跟着9位数字的学生信息。select * from students where phone_num regexp '^1[58][0-9]{9}';

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Md65gbaq-1650808207508)(C:\Users\16250\AppData\Roaming\Typora\typora-user-images\image-20220409182940614.png)]

1.12 排序（order by）

--查询出员工的所有信息，并将月薪按升序排序（asc可以省略，因为系统默认升序排序）select * from emp order by sal asc;--查询出员工的所有信息，并将月薪按降序排序select * from emp order by sal desc;

1.13 两个字段排序（order by 字段1 asc,字段2 asc）

--字段1的优先级更高，先满足字段1排序--查询出员工的所有信息，并将月薪按升序排序，若月薪相等则按姓名首字母升序排序（F < S）select * from emp order by sal asc,ename asc;显示：
|  7902 | FORD   | ANALYST   | 7566 | 1981-12-03 | 3000.00 |    NULL |     20 |
|  7788 | SCOTT  | ANALYST   | 7566 | 1987-04-19 | 3000.00 |    NULL |     20 |--查询出员工的所有信息，并将月薪按升序排序，若月薪相等则按姓名首字母降序排序select * from emp order by sal asc,ename desc;显示：
|  7788 | SCOTT  | ANALYST   | 7566 | 1987-04-19 | 3000.00 |    NULL |     20 |
|  7902 | FORD   | ANALYST   | 7566 | 1981-12-03 | 3000.00 |    NULL |     20 |

1.14 综合排序

--查询出月薪在1000到3000的员工信息，并按照月薪降序排序select * from emp where sal between 1000 and 3000 order by sal desc;显示：+-------+--------+----------+------+------------+---------+---------+--------+
| empno | ename  | job      | mgr  | hiredate   | sal     | comm    | deptno |
+-------+--------+----------+------+------------+---------+---------+--------+
|  7788 | SCOTT  | ANALYST  | 7566 | 1987-04-19 | 3000.00 |    NULL |     20 |
|  7902 | FORD   | ANALYST  | 7566 | 1981-12-03 | 3000.00 |    NULL |     20 |
|  7566 | JONES  | MANAGER  | 7839 | 1981-04-02 | 2975.00 |    NULL |     20 |
|  7698 | BLAKE  | MANAGER  | 7839 | 1981-05-01 | 2850.00 |    NULL |     30 |
|  7782 | CLARK  | MANAGER  | 7839 | 1981-06-09 | 2450.00 |    NULL |     10 |
|  7499 | ALLEN  | SALESMAN | 7698 | 1981-02-20 | 1600.00 |  300.00 |     30 |
|  7844 | TURNER | SALESMAN | 7698 | 1981-09-08 | 1500.00 |    0.00 |     30 |
|  7934 | MILLER | CLERK    | 7782 | 1982-01-23 | 1300.00 |    NULL |     10 |
|  7521 | WARD   | SALESMAN | 7698 | 1981-02-22 | 1250.00 |  500.00 |     30 |
|  7654 | MARTIN | SALESMAN | 7698 | 1981-09-28 | 1250.00 | 1400.00 |     30 |
|  7876 | ADAMS  | CLERK    | 7788 | 1987-05-23 | 1100.00 |    NULL |     20 |
+-------+--------+----------+------+------------+---------+---------+--------+

1.15 大小写

--查询出所有员工的姓名，且姓名都为小写字母 select lower(ename) from emp;显示：+--------------+
| lower(ename) |
+--------------+
| smith        |
| allen        |
| ward         |
+--------------+--查询出所有员工的姓名，且姓名都为小写字母，再把字段ename别名改emp_ename;select lower(ename) as emp_ename from emp;显示：+--------+
|emp_ename|
+--------+
| smith  |
| allen  |
| ward   |
+--------+--查询出所有员工的姓名，且姓名都为大写字母 select upper(ename) from emp;

1.16 substr

--概念1：从第m个字母开始查询员工姓名，长度为n（m不能是0，Java中0确实是表示第一个字母，但MySQL中1表示第一个字母）select substr(ename,m,n) from emp;--概念2：从第m个字母开始查询员工姓名，去掉姓名的倒数后n位select substr(ename,m,length(ename)-n) from emp;--查询所有员工的姓名select ename from emp;显示：+--------+
| ename  |
+--------+
| SMITH  |
| ALLEN  |
| WARD   |
+--------+--从第一个字母开始查询员工姓名，长度为1select substr(ename,1,1) from emp;显示：+-------------------+
| substr(ename,1,1) |
+-------------------+
| S                 |
| A                 |
| W                 |      |
+-------------------+--从第一个字母开始查询员工姓名，长度为3select substr(ename,1,3) from emp;显示：+-------------------+
| substr(ename,1,3) |
+-------------------+
| SMI               |
| ALL               |
| WAR               |
+-------------------+--从第二个字母开始查询员工姓名，长度为1select substr(ename,2,1) from emp;显示：+-------------------+
| substr(ename,2,1) |
+-------------------+
| M                 |
| L                 |
| A                 |
+-------------------+--从倒数第一个（最后一个）字母开始查询员工姓名，长度为1select substr(ename,-1,1) from emp;显示：+--------------------+
| substr(ename,-1,1) |
+--------------------+
| H                  |
| N                  |
| D                  |
+--------------------+--从第一个字母开始查询员工姓名，去掉姓名的最末位select substr(ename,1,length(ename)-1) from emp;显示：+---------------------------------+
| substr(ename,1,length(ename)-1) |
+---------------------------------+
| SMIT                            |
| ALLE                            |
| WAR                             |
+---------------------------------+--从第一个字母开始查询员工姓名，去掉姓名的倒数后两位select substr(ename,1,length(ename)-2) from emp;显示：+---------------------------------+
| substr(ename,1,length(ename)-2) |
+---------------------------------+
| SMI                             |
| ALL                             |
| WA                              |
+---------------------------------+

1.17 拼接concat、随机数rand、四舍五入round

--把员工姓名和员工号拼接在一起查询出来select concat(ename,empno) from emp;显示：+---------------------+
| concat(ename,empno) |
+---------------------+
| SMITH7369           |
| ALLEN7499           |
| WARD7521            |
+---------------------+--在emp表中生成一些随机数select rand() from emp;显示：+---------------------+
| rand()              |
+---------------------+
|  0.5352104115627803 |
| 0.16401791774110674 |
|  0.2144583847508378 |
+---------------------+--把随机数乘上百倍 （每次使用rand随机数都会发生变化）select rand()*100 from emp;显示：+--------------------+
| rand()*100         |
+--------------------+
|  80.40498614348935 |
| 26.853150806252984 |
|  93.05079867416136 |
+--------------------+--把随机数乘上百倍，结果四舍五入select round(rand()*100) from emp;显示：+-------------------+
| round(rand()*100) |
+-------------------+
|                99 |
|                 5 |
|                30 |
+-------------------+

1.18 统计（max、min、）

--查询出月薪的最大值select max(sal) from emp;显示：+----------+
| max(sal) |
+----------+
|  5000.00 |
+----------+--查询出月薪的最小值select min(sal) from emp;--查询出月薪的平均值select avg(sal) from emp;--查询出所有员工月薪的总值select sum(sal) from emp;--查询出员工月薪的个数（也就是多少个人有工资）select count(sal) from emp;

1.19 执行循序

--执行顺序from-->where-->group by-->select-->order by--错误范例：select sal from emp where sal>=min(sal);原因：min(sal)语句在where后面是不行的，要先分组！

1.20 分组查询group by（以及with rollup、group_concat()）

--查询员工月薪总值按照职位（job）进行分组select sum(sal),job from emp group by job;显示：+----------+-----------+
| sum(sal) | job       |
+----------+-----------+
|  6000.00 | ANALYST   |
|  4150.00 | CLERK     |
|  8275.00 | MANAGER   |
+----------+-----------+----查询员工月薪总值按照职位（job）进行分组，并按照月薪（sal）降序排序select sum(sal),job from emp group by job order by sum(sal) desc;该语句顺序：先执行from emp，再到 group by job --> select sum(sal) --> order by sum(sal) desc注意：分完组才能放在select和from之间

--with rollup汇总使用group by和聚集函数可以对记录进行分组汇总，对各组进行统计，分组汇总后可以使用with rollup汇总所有组的总汇总信息，该总汇总数据显示在所有记录的最后面。--例题：分组统计男女学生的名单，并显示总名单。SELECT sex,count(sex) FROM students GROUP BY sex WITH ROLLUP;

--group_concat()函数的功能：
1）将集合中的字符串连接起来，此时group_concat()函数的功能与字符串连接函数concat()的功能相似。
2）group_concat()函数还可以按照分组字段，将组中另一个字段的值（NULL值除外）使用逗号(默认)连接起来。 concat()却函数没有提供这样的功能。--例题1：使用group_concat()函数以及concat()函数负责将集合中('java', '程序', '设计')三个字符串连接起来。select group_concat('java','程序','设计'),concat('java','程序','设计');--例题2：按性别分组统计学生的名单，并显示总学生名单。SELECT sex,GROUP_CONCAT(s_name) FROM students GROUP BY sex WITH ROLLUP;显示：
+-----+--------------------------------------------------------------
| sex | GROUP_CONCAT(s_name)                                                                               |
+-----+---------------------------------------------------------------
| 男  | 王林,李刚,王林,程明,王敏,李子丹,张继刚,李刚,张小_
| 女  | 赵甜甜,李涛涛,马琳琳
| NULL| 王林,李刚,王林,程明,王敏,李子丹,张继刚,李刚,张小_,赵甜甜,李涛涛,马琳琳
+-----+---------------------------------------------------------------

1.21 分组查询（2）

--查询出每个部门不同岗位的最高薪资由题意可知：需要将部门（deptno）、岗位（job）进行分组select deptno,job,max(job) from emp group by deptno,job order by max(sal);显示：+--------+-----------+-----------+
| deptno | job       | max(job)  |
+--------+-----------+-----------+
|     30 | CLERK     | CLERK     |
|     20 | CLERK     | CLERK     |
|     10 | CLERK     | CLERK     |
|     30 | SALESMAN  | SALESMAN  |
|     10 | MANAGER   | MANAGER   |
|     30 | MANAGER   | MANAGER   |
|     20 | MANAGER   | MANAGER   |
|     20 | ANALYST   | ANALYST   |
|     10 | PRESIDENT | PRESIDENT |
+--------+-----------+-----------+--按岗位进行分组，查询出员工的岗位、部门、月薪select job,deptno,sal from emp order by deptno;显示：+-----------+--------+---------+
| job       | deptno | sal     |
+-----------+--------+---------+
| MANAGER   |     10 | 2450.00 |
| PRESIDENT |     10 | 5000.00 |
| CLERK     |     10 | 1300.00 |
| CLERK     |     20 |  800.00 |
| MANAGER   |     20 | 2975.00 |
| ANALYST   |     20 | 3000.00 |
| CLERK     |     20 | 1100.00 |
| ANALYST   |     20 | 3000.00 |
| SALESMAN  |     30 | 1600.00 |
| SALESMAN  |     30 | 1250.00 |
| SALESMAN  |     30 | 1250.00 |
| MANAGER   |     30 | 2850.00 |
| SALESMAN  |     30 | 1500.00 |
| CLERK     |     30 |  950.00 |
+-----------+--------+---------+

1.22 having (有group by时才能使用having)

--按部门分组，查询出月薪总值大于9000的部门select sum(sal),deptno from emp group by deptno having sum(sal)>9000 order by deptno;显示：+----------+--------+
| sum(sal) | deptno |
+----------+--------+
| 10875.00 |     20 |
|  9400.00 |     30 |
+----------+--------+--错误范例：select sum(sal),deptno from emp where sum(sal)>9000 group by  deptno order by deptno;原因：系统的执行顺序为 from-->where-->group by-->select-->order by因为where会比group by先执行，而sum(sal)语句需要在分组后才能使用，它却直接跟在where的后面，显然是不合法的！但是max(sal)与sum(sal)有些许差别！--按部门分组，查询出月薪最大值大于等于3000的部门select max(sal),deptno from emp where sal>=3000 group by deptno order by deptno;显示：+----------+--------+
| max(sal) | deptno |
+----------+--------+
|  5000.00 |     10 |
|  3000.00 |     20 |
+----------+--------+

1.23 distinct （去重服务）

-- DISTINCT表示去掉重复的行，作用是针对包含重复值的数据表，用于返回唯一不同的值。--去掉job中重复的岗位，再列出select distinct job from emp;显示：+-----------+
| job       |
+-----------+
| CLERK     |
| SALESMAN  |
| MANAGER   |
| ANALYST   |
| PRESIDENT |
+-----------+--去掉重复部门的重复的职位使用distinct去重服务，联合查询独一无二的的岗位与部门：select distinct job,deptno from emp;显示：+-----------+--------+
| job       | deptno |
+-----------+--------+
| CLERK     |     20 |
| SALESMAN  |     30 |
| MANAGER   |     20 |
| MANAGER   |     30 |
| MANAGER   |     10 |
| ANALYST   |     20 |
| PRESIDENT |     10 |
| CLERK     |     30 |
| CLERK     |     10 |
+-----------+--------+

1.24 笛卡尔积现象

--什么是笛卡尔积？假设身高集合为A={a1,a2,a3,a4……an}，体重集合为B = {b1,b2,b3,b4,b5……}，那么A X B = {<a1,b1>, <a1,b2> ,<a1, b3>,……<a1,bn>,<a2,b1>,<a2,b2>……<an,bn> }--查询每个员工（ename）对应的部门(dname)select ename,dname from emp,dept where emp.deptno = dept.deptno;显示：+--------+------------+
| SMITH  | RESEARCH   |
| ALLEN  | SALES      |
| WARD   | SALES      |
| JONES  | RESEARCH   |
| MARTIN | SALES      |
| BLAKE  | SALES      |
| CLARK  | ACCOUNTING |
| SCOTT  | RESEARCH   |
| KING   | ACCOUNTING |
| TURNER | SALES      |
| ADAMS  | RESEARCH   |
| JAMES  | SALES      |
| FORD   | RESEARCH   |
| MILLER | ACCOUNTING |
+--------+------------+--查询每个员工（ename）对应的部门(dname)，并将ename取别名为e，dname取别名为dselect e.ename,d.dname from emp as e,dept as d where e.deptno = d.deptno;这里可以写成select e.ename,d.dname ，是因为'from emp as e,dept as d语句'先执行，from——>select--错误范例：select ename,dname from emp,dept;显示：+--------+------------+
| ename  | dname      |
+--------+------------+
| SMITH  | ACCOUNTING |
| SMITH  | RESEARCH   |
| SMITH  | SALES      |
| SMITH  | OPERATIONS |
| ALLEN  | ACCOUNTING |
| ALLEN  | RESEARCH   |
| ALLEN  | SALES      |
| ALLEN  | OPERATIONS |
| WARD   | ACCOUNTING |
| WARD   | RESEARCH   |
| WARD   | SALES      |
| WARD   | OPERATIONS |
| JONES  | ACCOUNTING |
| JONES  | RESEARCH   |
| JONES  | SALES      |
| JONES  | OPERATIONS |
| MARTIN | ACCOUNTING |
| MARTIN | RESEARCH   |
| MARTIN | SALES      |
| MARTIN | OPERATIONS |
| BLAKE  | ACCOUNTING |
| BLAKE  | RESEARCH   |
| BLAKE  | SALES      |
| BLAKE  | OPERATIONS |
| CLARK  | ACCOUNTING |
| CLARK  | RESEARCH   |
| CLARK  | SALES      |
| CLARK  | OPERATIONS |
| SCOTT  | ACCOUNTING |
| SCOTT  | RESEARCH   |
| SCOTT  | SALES      |
| SCOTT  | OPERATIONS |
| KING   | ACCOUNTING |
| KING   | RESEARCH   |
| KING   | SALES      |
| KING   | OPERATIONS |
| TURNER | ACCOUNTING |
| TURNER | RESEARCH   |
| TURNER | SALES      |
| TURNER | OPERATIONS |
| ADAMS  | ACCOUNTING |
| ADAMS  | RESEARCH   |
| ADAMS  | SALES      |
| ADAMS  | OPERATIONS |
| JAMES  | ACCOUNTING |
| JAMES  | RESEARCH   |
| JAMES  | SALES      |
| JAMES  | OPERATIONS |
| FORD   | ACCOUNTING |
| FORD   | RESEARCH   |
| FORD   | SALES      |
| FORD   | OPERATIONS |
| MILLER | ACCOUNTING |
| MILLER | RESEARCH   |
| MILLER | SALES      |
| MILLER | OPERATIONS |
+--------+------------+
56 rows in set (0.00 sec)
原因：这显然是笛卡尔积，把 'select ename from emp;语句' 和'select dname from dept;语句'进行笛卡尔积，得到的结果就是14*4=56，一共有56条记录!

在多表连接查询中，内连接是一种最常用的连接类型

--内连接在<连接条件>中指明两个表按什么条件进行连接，<连接条件>中的比较运算符称为连接谓词。注意：当比较运算符为（=）时，称为等值连接，使用其他运算符的连接称为非等值连接

--表之间的连接有：交叉连接（Cross Join）、内连接（Inner Jion）、外连接（Outer Join）和自连接（Self Join）和自然连接（Natural join）

--交叉连接（Cross Join）交叉连接不带Where子句（或连接条件on），它返回两个表的笛卡尔积。实际应用中仅一些特殊需求使用。--例：查询所有可能的选课情况。SELECT s_no,s_name,c_no,c_name FROM students,course;等同于：SELECT s_no,s_name,c_no,c_name FROM students CROSS JOIN course;

1.25 内连接等值连接

--表1 inner join 表2 on 表1.关键字段 = 表2.关键字段 （inner可省略）--使用内连接查询每个员工（ename）对应的部门(dname)select ename,dname from emp inner join dept on emp.deptno = dept.deptno;--查询每个员工（ename）对应的部门(dname)，并将ename取别名为e，dname取别名为dselect e.ename,d.dname from emp as e inner join dept as d on e.deptno = d.deptno;显示结果与上面一致

1.26 内连接非等值连接

--插入一个月薪等级表（salgrade）salgrade数据显示：mysql> select * from salgrade;+-------+---------+---------+
| grade | losal   | hisal   |
+-------+---------+---------+
|     1 |  700.00 | 1200.00 |
|     2 | 1201.00 | 1400.00 |
|     3 | 1401.00 | 2000.00 |
|     4 | 2001.00 | 3000.00 |
|     5 | 3001.00 | 9999.00 |
+-------+---------+---------+--查询每个员工月薪所对应的等级，列出员工姓名和等级select ename,grade from emp inner join salgrade on emp.sal between salgrade.losal and salgrade.hisal;显示：+--------+-------+
| ename  | grade |
+--------+-------+
| SMITH  |     1 |
| ALLEN  |     3 |
| WARD   |     2 |
| JONES  |     4 |
| MARTIN |     2 |
| BLAKE  |     4 |
| CLARK  |     4 |
| SCOTT  |     4 |
| KING   |     5 |
| TURNER |     3 |
| ADAMS  |     1 |
| JAMES  |     1 |
| FORD   |     4 |
| MILLER |     2 |
+--------+-------+

1.27 自连接（是一种特殊的内连接，也是使用 inner join）

--定义：自连接是一种特殊的内连接，它是指相互连接的表在物理上为同一张表，但在逻辑上将其看成是两张表。而要让物理上的一张表在逻辑上成为两张表，必须通过为表取别名的方法。--其实自连接，就是说把emp表相当于是两张表，以第一张表的id（mgr）为主，去匹配与它对应的第二张表的id（empno）
--mgr是经理编号，empno是员工编号+-------+--------+-----------+------+------------+---------+---------+--------+
| empno | ename  | job       | mgr  | hiredate   | sal     | comm    | deptno |
+-------+--------+-----------+------+------------+---------+---------+--------+
|  7369 | SMITH  | CLERK     | 7902 | 1980-12-17 |  800.00 |    NULL |     20 |
|  7499 | ALLEN  | SALESMAN  | 7698 | 1981-02-20 | 1600.00 |  300.00 |     30 |--使用自连接查询每个员工所对应的领导select a.ename as 经理,b.ename as 员工 from emp as a inner join emp as b on a.mgr = b.empno;显示：+--------+--------+
| 经理   | 员工   |
+--------+--------+
| SCOTT  | JONES  |
| FORD   | JONES  |
| ALLEN  | BLAKE  |
| WARD   | BLAKE  |
| MARTIN | BLAKE  |
| TURNER | BLAKE  |
| JAMES  | BLAKE  |
| MILLER | CLARK  |
| ADAMS  | SCOTT  |
| JONES  | KING   |
| BLAKE  | KING   |
| CLARK  | KING   |
| SMITH  | FORD   |
+--------+--------+提示：把mgr字段和empno字段分别看成两张表；mgr为主表（起别名为 a），去empno表（起别名为 b）中检索对应的数据，进行比较，若相同，则表明a.enmae（经理）管理着b.ename（员工）

--查询和“王林”在同一个系的学生的学号、姓名和系别编号。select distinct a.s_no,a.s_name,a.d_no from students as a inner join students as b on a.d_no = b.d_no and b.s_name = '王林' and a.s_name<>'王林';提示：distinct是去重服务。由于题中要求统一系，所以表的连接条件与d_no有关：on a.d_no = b.d_no。以a表为主表，b表为副表，查询最后会返回a表的内容。检索b表中名字为王林所在的系号：and b.s_name = '王林' 又要求最后检索出来的内容不包含王林的记录：and a.s_name<>'王林'

1.28 外连接

--外连接 (OUTER JOIN)分为三种：
左外连接 (LEFT OUTER JOIN 或 LEFT JOIN) ，
右外连接 (RIGHT OUTER JOIN 或 RIGHT JOIN) ，
全外连接 (FULL OUTER JOIN 或 FULL JOIN)。 --左外连接：from 表1 left join 表2 on <连接条件>；以左边的表1为主，去右边的表2里检索对应数据，最后输出表1的内容。--右外连接：from 表1 right join 表2 on <连接条件>；以右边的表2为主，去左边的表1里检索对应数据，最后输出表2的内容。--以员工（empno）为主，使用外连接查询对应的领导（mgr）select b.ename as 员工名,a.ename as 领导名 from emp as a right join emp as b on b.empno = a.mgr;显示：+-----------+-----------+
| 员工名    | 领导名    |
+-----------+-----------+
| FORD      | SMITH     |
| BLAKE     | ALLEN     |
| BLAKE     | WARD      |
| KING      | JONES     |
| BLAKE     | MARTIN    |
| KING      | BLAKE     |
| KING      | CLARK     |
| JONES     | SCOTT     |
| BLAKE     | TURNER    |
| SCOTT     | ADAMS     |
| BLAKE     | JAMES     |
| JONES     | FORD      |
| CLARK     | MILLER    |
| SMITH     | NULL      |
| ALLEN     | NULL      |
| WARD      | NULL      |
| MARTIN    | NULL      |
| TURNER    | NULL      |
| ADAMS     | NULL      |
| JAMES     | NULL      |
| MILLER    | NULL      |
+-----------+-----------+

1.29 三表查询

--查询员工名，以及所对应的部门名，还有对应的薪资等级select e.ename,d.dname,s.grade from emp as e inner join dept as d on e.deptno=d.deptno inner join salgrade as s on e.sal between s.losal and s.hisal;显示：+--------+------------+-------+
| ename  | dname      | grade |
+--------+------------+-------+
| SMITH  | RESEARCH   |     1 |
| ADAMS  | RESEARCH   |     1 |
| JAMES  | SALES      |     1 |
| WARD   | SALES      |     2 |
| MARTIN | SALES      |     2 |
| MILLER | ACCOUNTING |     2 |
| ALLEN  | SALES      |     3 |
| TURNER | SALES      |     3 |
| JONES  | RESEARCH   |     4 |
| BLAKE  | SALES      |     4 |
| CLARK  | ACCOUNTING |     4 |
| SCOTT  | RESEARCH   |     4 |
| FORD   | RESEARCH   |     4 |
| KING   | ACCOUNTING |     5 |
+--------+------------+-------+

1.30 子查询：where （子查询语句）

--定义：一个select语句嵌套在另一个select语句中，总是把子查询写在圆括号中。--查询月薪大于最小月薪的员工，列出员工名和月薪（不使用子查询）第一步：查询出最少月薪select min(sal) from emp;显示：+----------+| min(sal) |+----------+|   800.00 |+----------+第二步：select ename,sal from emp where sal>800;显示：+--------+---------+| ename  | sal     |+--------+---------+| ALLEN  | 1600.00 || WARD   | 1250.00 || JONES  | 2975.00 |+--------+---------+--使用子查询，查询月薪大于最小月薪的员工，列出员工名和月薪select ename,sal from emp where sal>(select min(sal) from emp);        --错误范例：select ename,sal from emp where sal>min(sal);原因：min(sal)是分组函数，必须分组后才能使用，而where的执行循序高于group by! from-->where-->group by-->select-->order by

嵌套查询、联合查询（不相关子查询、相关子查询）

--嵌套查询、联合查询：一、要点：1) 带比较运算符的子查询2) 带IN、ANY、ALL运算符的子查询3) 带EXISTS谓词的子查询4）联合查询UNION--子查询定义：在SQL语言中，将一个SELECT…FROM…WHERE称为一个查询块。将一个查询块嵌套在另一个查询的WHERE或HAVING     子句的条件中称为嵌套查询（子查询）。SQL语言允许多层嵌套，即一个子查询中还可以包括其它子查询。--子查询一般分为两种：不相关子查询和相关子查询。注意：子查询中不能用ORDER BY！

不相关子查询

--一、不相关子查询定义：子查询的执行不依赖于外层查询，子查询可以独立执行，其查询结果作为外层查询的条件使用。所以，在执行时首先执行子查询，然后将其结果作为外层主查询的条件，执行外层查询。--1.1返回单个值的子查询：通常会用到运算符如：=，>，>=，<，<=，<>，!= 等--1.2返回多个值的子查询：常用运算符有：IN，NOT  IN，ANY（SOME），ALL等。--In是子查询中最常用的运算符，用于判断外层查询中的某个属性值是否在子查询结果（集）中。not in与之相反。--ANY和ALL的用法和具体含义:用 法                    含 义>ANY  大于子查询结果中的某个值。即：大于最小的(>MIN)>ALL 大于子查询结果中的所有值，即：大于最大的(>MAX)<ANY  小于子查询结果中的某个值。即：小于最大的(<MAX)<ALL 小于子查询结果中的所有值。即：小于最小的(<MIN)>=ANY   大于等于子查询结果中的某个值>=ALL 大于等于子查询结果中的所有值<=ANY 小于等于子查询结果中的某个值<=ALL 小于等于子查询结果中的所有值=ANY 等于子查询结果中的某个值（等价于IN）=ALL  等于子查询结果中的所有值（通常无实际意义）!=ANY或< >ANY  不等于子查询结果中的某个值!=ALL或< >ALL    不等于子查询结果中的任何一个值(等价于NOT IN)

--1.1不相关子查询中返回单个值的例题：--例题1：查询成绩高于所有成绩总平均分的学生的学号、课程号和成绩。select s_no,c_no,report from score where report>(select avg(report) from score);--例题2：查询选修了“算法与程序设计”的所有学生的学号。法一：使用嵌套查询select s_no from score where c_no = (select c_no from course where c_name = '算法与程序设计'); 法二：不使用嵌套查询，使用多表连接查询select s_no from score as sc inner join course as co on sc.c_no=co.c_no where c_name='算法与程序设计';--例题3：查询年龄小于所有学生平均年龄的学生学号、姓名。select s_no,s_name from students where year(curdate())-year(birthday) <(select avg(year(curdate())-year(birthday)) from students);提示：year(curdate())指的是今天的日期，year(birthday) 是出生日期--查询和“王林”在同一个系的学生的学号、姓名和系别编号。select s_no,s_name,d_no from studentswhere d_no = (select distinct d_no from students where s_name = '王林');

--1.2不相关子查询中返回多个值的例题：--例题1：查询选修了“算法与程序设计”的学生的学号和姓名。select s_no,s_name from students where s_no in (select s_no from score where c_no = (select c_no from course where c_name = '算法与程序设计'));
提示：它需要用到三个表，一层套一层！--例题2：使用ALL，查询“003”系年龄比“001”系年龄最大的学生还要大的学生，列出学号、姓名。select s_no,s_name from students WHERE d_no='003' and YEAR(CURDATE())-YEAR(birthday)>ALL(select YEAR(CURDATE())-YEAR(birthday) from students where d_no = '001');提示：>ALL 大于子查询结果中的所有值。--例题3：使用ANY,查询所有年龄比“001”系年龄最小的学生要大的学生的学生，列出学号、姓名和年龄。SELECT s_no,s_name,YEAR(CURDATE())-YEAR(birthday) from students WHERE YEAR(CURDATE())-YEAR(birthday)>ANY(select YEAR(CURDATE())-YEAR(birthday) from students where d_no = '001');

相关子查询：EXISTS（∃）运算符

--相关子查询：相关子查询的执行依赖于外部查询的数据（即子查询的条件依赖于外部查询的某个属性），外部查询执行   一行，子查询就执行一次。--常用的是EXISTS（∃）运算符， 用于检测子查询的结果集是否包含记录，如果子查询的结果集中至少包含一条记录，则    exists的结果为True，否则为false。--相关子查询的执行过程：首先取外层查询中表的第一个元组，根据它与内层查询相关的属性值处理内层查询，若WHERE子句返回值为真，则取此元组放入结果表；然后再取外层表的下一个元组；重复这一过程，直至外层表全部检查完为止。--注意点：1.由于带有EXISTS谓词的子查询不返回任何数据，只返回逻辑真值“true”或逻辑假值“false”，所以，由EXISTS引出的子查询，其目标列表达式通常都用* ，给出列名无实际意义；2.所有带比较运算符、IN和ALL的子查询都能用带EXISTS的子查询等价替换，但一些带EXISTS或NOT EXISTS的子查询不能被其他形式的子查询等价替换。

--例题1：使用exists，查询选修了“01”号课程的学生的学号和姓名。法一：使用相关子查询select s_no,s_name from students as stwhere exists (select * from score where s_no = st.s_noand c_no = '01'); 法二：使用外联查询select st.s_no,s_name from students as st LEFT JOIN score as sc on st.s_no=sc.s_nowhere c_no='01';--例题2：使用 not exists，查询没有选修“01”号课程的学生的学号和姓名。select s_no,s_name from studentswhere not exists(select * from score where s_no = students.s_noand c_no = '01');  --典型exists例子：查询选修了全部课程的学生的姓名。SELECT  s_nameFROM  studentsWHERE  NOT EXISTS             /*语义：不存在一门课程*/(SELECT * FROM courseWHERE NOT EXISTS              /*语义：该同学没有选修*/(SELECT * FROM score WHEREs_no = students.s_noAND c_no = course.c_no ));提示：SQL中无全称量词(for all)，所以将语义转换为“没有一门课是他不选的”SELECT * FROM courseWHERE NOT EXISTS (SELECT * FROM score where c_no = course.c_no);/*查询出score表内没有的course表的数据06 大学物理    32  2   选修*/

1.31 子查询：from （子查询语句）

--查询所有岗位的平均工资select job,avg(sal) from emp group by job;显示：+-----------+-------------+
| job       | avg(sal)    |
+-----------+-------------+
| ANALYST   | 3000.000000 |
| CLERK     | 1037.500000 |
| MANAGER   | 2758.333333 |
| PRESIDENT | 5000.000000 |
| SALESMAN  | 1400.000000 |
+-----------+-------------+--查询所有岗位的平均工资，再连接salgrade表，评出等级提示：把（查询所有岗位的平均工资）当成一张表，起别名为tselect t.job,t.avg_sal,s.grade from (select job,avg(sal) as avg_sal from emp group by job) as t inner join salgrade as s on avg_sal between s.losal and s.hisal;显示：+-----------+-------------+-------+
| job       | avg_sal     | grade |
+-----------+-------------+-------+
| ANALYST   | 3000.000000 |     4 |
| CLERK     | 1037.500000 |     1 |
| MANAGER   | 2758.333333 |     4 |
| PRESIDENT | 5000.000000 |     5 |
| SALESMAN  | 1400.000000 |     2 |
+-----------+-------------+-------+--查询所有岗位的平均工资，再连接salgrade表，评出等级，再进行排序select t.job,t.avg_sal,s.grade from (select job,avg(sal) as avg_sal from emp group by job) as t inner join salgrade as s on avg_sal between s.losal and s.hisal order by grade;显示：+-----------+-------------+-------+
| job       | avg_sal     | grade |
+-----------+-------------+-------+
| CLERK     | 1037.500000 |     1 |
| SALESMAN  | 1400.000000 |     2 |
| ANALYST   | 3000.000000 |     4 |
| MANAGER   | 2758.333333 |     4 |
| PRESIDENT | 5000.000000 |     5 |
+-----------+-------------+-------+

1.32 联合查询 union （集合操作）

--联合查询是指将多个SELECT语句返回的结果通过UNION合并到一个结果集。语法格式如下：Select 字段列表1 from 表1Union [all]Select 字段列表2 from 表2注意点：1.字段列表1和字段列表2的字段个数必须相同，数据类型也要兼容；2.合并后的结果集的字段名与字段列表1中的字段名对应；3.Union 会去掉结果集中的重复记录，union all 则直接合并结果集。--将多个结果合并在一起显示出来，union会自动压缩多个结果集合中的重复结果--查询出员工号为7369和7499的员工select ename from emp where empno=7369 or empno=7499;显示：+-------+
| ename |
+-------+
| SMITH |
| ALLEN |
+-------+--使用union语句，查询出员工号为7369和7499的员工select ename from emp where empno=7369 union select ename from emp where empno=7499;显示：+-------+
| ename |
+-------+
| SMITH |
| ALLEN |
+-------+--虽然上面两种方法结果一样，但union还是有不可忽视的作用：它能减少笛卡尔积的现象，大大提高了效率！把多表连接的数据量（数据量*数据量*数据量*数据量……）转化为（数据量+数据量+数据量+数据量……）

1.33 limit （limit 起始,条数）

--如果只想列出自己想要的某几行数据，可以使用limit子句来限制产生的结果集行数--查询emp表的前三条数据，列出员工名和月薪select ename,sal from emp order by sal limit 0,3;提示：0是起始下标，表示从第一条开始；3是要查询的条数显示：+-------+---------+
| ename | sal     |
+-------+---------+
| SMITH |  800.00 |
| JAMES |  950.00 |
| ADAMS | 1100.00 |
+-------+---------+--查询月薪最高的前三名员工，列出员工和月薪select ename,sal from emp order by sal desc limit 0,3;提示：为什么使用desc降序排列，因为order by默认是升序排列，若是升序排列，查询出的就是最低工资的前三名。显示：+-------+---------+
| ename | sal     |
+-------+---------+
| KING  | 5000.00 |
| FORD  | 3000.00 |
| SCOTT | 3000.00 |
+-------+---------+--查询月薪最高的第三到第五名员工，列出员工和月薪select ename,sal from emp order by sal desc limit 2,3;提示：2是起始位置，和java语言中的数组下标一样，指的是第三个；3是数据条数，因为要求的是月薪最高的第三到第五名员工，一共需要三条记录（第三名，第四名和第五名）显示：+-------+---------+
| ename | sal     |
+-------+---------+
| SCOTT | 3000.00 |
| JONES | 2975.00 |
| BLAKE | 2850.00 |
+-------+---------+

1.34 创建表删除表

--创建一个students表：create table students(name varchar(32),age int(3),email varchar(255),sex char(1));--删除一个students表：drop table students;提示：若输入两次则会报错--另一种删除方法：若存在则删除，否则不删除（防止报错）drop table if exists students;

1.35 插入数据 insert

--插入模板（方便使用）
insert into students values('','','','','','','','','','','',);
insert into students values('','',default,null,'',null,null,null,null);

--表记录有两种insert插入形式：insert语句向表中插入一条或者多条记录。insert….select语句向表中插入一个查询的结果集。 --1. 使用insert语句插入新记录语法格式：insert into 表名 [(字段列表)]  values (值列表)注意点：带默认约束的字段，可使用Default关键字；自增型auto_increment字段建议插入NULL，其值由MySQL自动维护。--2. 批量插入多条记录一次性地向表批量插入多条记录，语法格式如下：insert into 表名[(字段列表)] values(值列表1),(值列表2),…(值列表n);--3. 使用insert…select语句向表中，插入查询结果可以将某个查询结果添加到目标表中，语法格式如下：insert into 目标表名[(字段列表1)] select (字段列表2) from 源表 where 条件表达式注意：字段列表1与字段列表2的字段个数必须相同，且对应字段的数据类型尽量保持一致。如果源表与目标表的表结构完全相同，“(字段列表1)”可以省略。

--4. 使用replace插入新记录（可以替换已有记录）MySQL中的replace语句的语法格式有三种语法格式。replace into 表名 [（字段列表）] values （值列表）replace [into] 表名 set 字段1=值1, 字段2=值2replace [into] 目标表名[(字段列表1)] select (字段列表2) from 源表 where 条件表达式

-- replace语句的功能与insert语句的功能基本相同，不同之处在于：如果新记录的主键值或者唯一性约束的字段值与已有记录相同，则已有记录先被删除（注意：已有记录删除时也不能违背外键约束条件），然后再插入新记录。--replace优点：可以将delete和insert合二为一，形成一个原子操作，这样就无需将delete操作与insert操作置于事务中了。

--先查看students表的结构desc students;显示：+-------+--------------+------+-----+---------+-------+
| Field | Type         | Null | Key | Default | Extra |
+-------+--------------+------+-----+---------+-------+
| name  | varchar(32)  | YES  |     | NULL    |       |
| age   | int(3)       | YES  |     | NULL    |       |
| email | varchar(255) | YES  |     | NULL    |       |
| sex   | char(1)      | YES  |     | NULL    |       |
+-------+--------------+------+-----+---------+-------+--插入一条数据insert into students(name,age,email,sex) values('zhangsan',10,'zhangsan@qq.com','男');查看插入结果：select * from students;显示：+----------+------+-----------------+------+
| name     | age  | email           | sex  |
+----------+------+-----------------+------+
| zhangsan |   10 | zhangsan@qq.com | 男   |
+----------+------+-----------------+------+--错误范例：insert into students(name,age,email,sex) values('lisi');原因：没有一一对应改正：insert into students(name) values('lisi');查看后显示：+----------+------+-----------------+------+
| name     | age  | email           | sex  |
+----------+------+-----------------+------+
| zhangsan |   10 | zhangsan@qq.com | 男   |
| lisi     | NULL | NULL            | NULL |
+----------+------+-----------------+------+--另一种插入方法，直接插入数据insert into students values('wangwu',12,'wangwu@qq.com','m');显示：+----------+------+-----------------+------+
| name     | age  | email           | sex  |
+----------+------+-----------------+------+
| zhangsan |   10 | zhangsan@qq.com | 男   |
| lisi     | NULL | NULL            | NULL |
| wangwu   |   12 | wangwu@qq.com   | m    |
+----------+------+-----------------+------+

--把students表的结构改一下，使得插入数组中的性别默认为男（提示：sex char(1) default '男'）--原代码：create table students(name varchar(32),age int(3),email varchar(255),sex char(1));--修改后：create table students(name varchar(32),age int(3),email varchar(255),sex char(1) default '男');

1.36 update（更新，修改数据）

--将'lisi'的性别修改为'女'update students set age=12,email='lisi@qq.com',sex='女' where name='lisi';注意：更新不需要加圆括号，插入数据时才要加（）！注意：一定要写where，没有设置条件的话，它会把所有数据都修改了！

1.37 delete （删除数据）

--删除关于lisi的一整条记录delete from students where name = 'lisi';--删除关于年龄为10的一整条记录delete from students where age = 10;--删除students表的全部数据delete from students;--附加：可以使用rollback；来进行事务回滚。但是使用“truncate table 表名”语句，则无法事务回滚！

--复制表create table 新表名 as select * from 表名;

--truncate删除语句格式：truncate table 表名与delete的区别：1、在功能上，truncate是清空一个表的内容，它相当于delete from table_name。 2、delete是dml操作，truncate是ddl操作；因此，用delete删除整个表的数据时，会产生大量的roolback，占用很多的rollback segments， 而truncate不会。3、 TRUNCATE TABLE删除表中的所有行，但表结构及其列、约束、索引等保持不变。4、 TRUNCATE TABLE不能用于参与了索引视图的表。

1.38 not null（非空约束）

--非空约束，这里的not null指的是插入时一定要有姓名namecreate table students(age int,name varchar(255) not null);--正确插入语句：insert into students(age,name) values(10,'lisa'),(18,'alex');--错误范例：insert into students(age) values(15);显示：ERROR 1364 (HY000): Field 'name' doesn't have a default value原因：name不能为空。

1.39 unique （唯一性约束）

--unique唯一性约束：使得插入的数据不能出现重复。--create table t_1(age int,name varchar(255) unique);--插入三条数据insert into t_t(age,name) values(10,'lisa'),(18,'alex'),(20,'xiaoming');--再插入一条也叫‘xiaoming’的人，会发现报错！insert into t_t(age,name) values(25,'xiaoming');显示：ERROR 1062 (23000): Duplicate entry 'xiaoming' for key 'name'原因：在这个表中，使用了unique约束了name，所以姓名name是主键，不能重复！

--删除刚刚的t_t表drop table if exists t_t;

1.40 unique （表约束）

--(字段1,字段2)unique：指的是不允许插入数据时，字段1和字段2同时重复--create table t_t(age int(10),name varchar(255), unique (age,name) );--插入一条数据insert into t_t (age,name) values (21,'xiaohong');--再插入相同，则会报错insert into t_t (age,name) values (21,'xiaohong');原因：字段1和字段2同时重复

1.41 not null unique（非空、主键约束）

--create table t_t(id int(10) not null unique,       //表示id不能为空，又将id称为主键age int(10),name varchar(255));等同于：create table t_t(id int(10),age int(10),name varchar(255),PRIMARY KEY(id));--查看t_t表结构desc t_t;显示：+-------+--------------+------+-----+---------+-------+
| Field | Type         | Null | Key | Default | Extra |
+-------+--------------+------+-----+---------+-------+
| id    | int(10)      | NO   | PRI | NULL    |       |
| age   | int(10)      | YES  |     | NULL    |       |
| name  | varchar(255) | YES  |     | NULL    |       |
+-------+--------------+------+-----+---------+-------+
提示：PRI是PRIMARY KEY的缩写，主键（PRIMARY KEY）的完整称呼是“主键约束”，是 MySQL 中使用最为频繁的约束。所以，id int(10) not null unique语句也可写为id int(10) PRIMARY KEY。

1.42 主键自增：primary key auto_increment(字段名)

--三种写法设置主键自增：create table t_t(id int(10) primary key auto_increment,      //主键自增age int(10),name varchar(255));等同于：create table t_1(id int(10) auto_increment,         /*id字段自增*/age int(10),name varchar(255),primary key (id)                    /*再设置为主键*/);等同于：create table t_2(id int(10),     age int(10),name varchar(255),primary key auto_increment(id)        //主键自增);--insert into t_t(age,name) values(10,'小明');insert into t_t(age,name) values(16,'小红');insert into t_t(age,name) values(16,'小白');insert into t_t(age,name) values(16,'小黑');--查看t_t表select * from t_t;显示：+----+------+--------+
| id | age  | name   |
+----+------+--------+
|  1 |   16 | 小黑   |
|  2 |   10 | 小明   |
|  3 |   16 | 小红   |
|  4 |   16 | 小白   |
+----+------+--------+主键（id）从1开始自增

1.43 外键

--班级classno classname1001     一班1002    二班--学生no classno calssname1  1001     一班2  1002     二班3  1003提示：使得1003不可能存在--创建的话，先建父表（class），再建子表（students）create table class(classno int primary key,name varchar(255));create table students(name varchar(255),no int primary key auto_increment,            /*设置序号为主键并自增*/age int,classno int,foreign key(classno) references class(classno)     /*class表中的主键classno，是students表的外键*/);显示：mysql> desc students;
+---------+--------------+------+-----+---------+----------------+
| Field   | Type         | Null | Key | Default | Extra          |
+---------+--------------+------+-----+---------+----------------+
| name    | varchar(255) | YES  |     | NULL    |                |
| no      | int(11)      | NO   | PRI | NULL    | auto_increment |
| age     | int(11)      | YES  |     | NULL    |                |
| classno | int(11)      | YES  | MUL | NULL    |                |
+---------+--------------+------+-----+---------+----------------+--向class表插入数据insert into class values(1001,'一班');insert into class values(1002,'二班');--向students表插入数据insert into students(name,age,classno) values('张三',18,'1001');insert into students(name,age,classno) values('王五',17,'1001');insert into students(name,age,classno) values('张三',19,'1002');--表数据都建完，即可查询select s.name,s.no,s.age,c.name from students as s,class as c where s.classno=c.classno;/*s.classno=c.classno 表示students表的外键是class表的主键*/显示：+--------+----+------+--------+
| name   | no | age  | name   |
+--------+----+------+--------+
| 张三   |  1 |   18 | 一班   |
| 王五   |  2 |   17 | 一班   |
| 张三   |  3 |   19 | 二班   |
+--------+----+------+--------+--附加：删除的话，先删子表（students），再删父表（class）。drop table students; drop table class;

1.44 事务开启（回滚）

--开启事务start transaction;--随便输入一条删除语句delete from t_1;--再事务回滚，发现删除的东西还在，因为回到了事务开启的时间点rollback;提示：但有时表内数据会被删除，表还在！--提交，关闭事务回滚commit;

1.45 视图

（1）视图的创建、修改和删除

--什么是视图？视图(View)是常用的数据库对象，它往往和外模式联系在一起，是简化查询、保证数据逻辑独立性、安全性等途径之一。--概念：    视图是数据库对象之一，是一张虚拟表，它表示一张表的部分数据或多张表的综合数据，其结构和数据是建立在对表的查询基础上。--作用：简化了数据访问操作，对经常使用，基于多表的复杂select语句，可以集中到一个视图，使查询变得简单。因为隐藏了底层的表结构，所以大大加强了安全性，不同用户只能查看或修改与其对应的数据。使用视图，方便了权限管理，让用户对视图有权限而不是对底层表有权限进一步加强了安全性。 视图提高了数据的逻辑独立性，当底层表改变后，通过改变视图的定义语句来进行适应，使已经建立在这个视图上的客户端程序不受影响 。--语法格式：
CREATE
[OR REPLACE]
[ALGORITHM = {UNDEFINED | MERGE | TEMPTABLE}]
[DEFINER = { user | CURRENT_USER }]
[SQL SECURITY { DEFINER | INVOKER }]
VIEW 视图名 [(列名列表)]
AS  select查询语句
[WITH [CASCADED | LOCAL] CHECK OPTION]--各个语句的功能：
OR REPLACE：              若不省略OR REPLACE子句，则能够替换已有的同名视图。
ALGORITHM子句：            可选的ALGORITHM子句是对标准SQL的MySQL扩展，规定了MySQL的算法，算法会影响MySQL处理视图的方式。Select语句：              用来创建视图的SELECT语句，可以查询多个表或视图。
WITH CHECK OPTION：       强制通过视图执行的所有数据修改语句必须符合视图定义中where子句设置的条件。
[CASCADED | LOCAL]选项：  当视图是由另一个视图定义时设置的检查范围，默认为cascaded，级联检查所有视图。

--视图是一个虚拟表，其内容由查询定义。--创建视图的语法create view 视图名 asselect 字段名from 表名where <条件>;--更新视图alter view 视图名 asselect 字段名from 表名where <条件>;--删除视图drop view 视图名;--注意：视图总是显示最新数据！若我们向表中写入新数据，那么视图它会自动更新。--创建一个以'广东省'为省份的视图create view Customer_GD asselect * from Customers where 省份='广东省';--查询刚刚创建的视图select * from Customer_GD;--为Customer_GD视图更新一个条件客户id=6alter view Customer_GD asselect * from Customers where 省份='广东省' and 客户id=6;--删除Customer_GD视图drop view Customer_GD;

--查看视图：注：若使用命令行客户端，可使用下列语句和方法查看视图。使用命令“show tables”除了可以查看数据库中的基本表以外，同时会列出所有的视图（如上右图）。使用命令“desc 视图名”，可查看视图的结构。 命令“show create view（或table）视图名”，可以查看视图定义的详细信息。视图的定义保存在系统数据库information_schema的views表中，可使用语句“SELECT * FROM information_schema.VIEWS WHERE TABLE_SCHEMA='coursedb';”查看coursedb数据库中的所有视图。磁盘上，可以在MySQL的data\coursedb\目录 中查看stu_view.frm文件。

（2）通过视图查询基本表

--一、视图定义后，就可以如同查询基本表那样对视图进行查询。（从用户角度来看）1. 先基于score表，创建coursedb数据库上的学生的平均成绩视图xs_avg，包括学号（在视图中列名为“学号”）和平均成绩（在视图中列名为“平均成绩”）。create view xs_avg(学号, 平均成绩)asselect s_no,avg(report)from scoregroup by s_no;2. 在视图xs_avg中查询平均成绩在85以上的学生的学号、平均成绩。select 学号,平均成绩 from xs_avg where 平均成绩>=85;--二、视图消解法：执行视图查询的过程（从DBMS角度看）含义：View Resolution，即将对视图的查询转化为对基本表的查询的方法。过程：   进行有效性检查，检查相关表、视图等是否存在，如果存在则从数据字典中取出视图的定义。把视图定义中的select和用户查询结合起来，转换成等价的对基本表的查询。执行修正后的查询。使用视图视图消解法，查询平均成绩在85以上的学生的学号、平均成绩。SELECT s_no as 学号,avg(report) as 平均成绩 FROM score GROUP BY s_no HAVING avg(report)>=85;--视图实体化法：执行视图查询的方法（从DBMS角度看）含义：进行有效性检查，检查视图是否存在，存在则执行定义，将视图临时实体化，生成临时表；查询临时表。查询完毕删除临时表（实体化的视图）。--例题：通过kc_cj 视图，查询001系（计算机）成绩在85以上的学生学号、课程号和成绩。SELECT s_no,c_no,report FROM kc_cj WHERE report>=85;--视图简化了查询语句。

（3）更新视图

--更新视图（插入、删除、修改）数据实际上是更新和视图关联的基本表的数据。然而视图的更新是受一定限制的，并非所有的视图都可以进行更新操作。--包含以下结构的视图不可更新
（1）聚合函数；
（2）DISTINCT关键字；
（3）GROUP BY子句；
（4）ORDER BY子句；
（5）HAVING子句；
（6）UNION运算符；
（7）位于选择列表中的子查询；
（8）FROM子句中包含多个表；
（9）SELECT语句中引用了不可更新视图；
（10）WHERE子句中的子查询，引用FROM子句中的表；

--向视图中插入数据insert into 视图名 values();--当视图所依赖的基本表有多个时，不能向该视图插入数据，因为这将会影响多个基本表例如：course_score_view视图依赖多个表

（4）更新视图

--修改数据：使用UPDATE语句可以通过视图修改基本表的数据。--例题：将jsj_xs视图中学生李牧的家庭地址改为“河南”。update jsj_xs set address=‘河南’ where s_name='李牧';--注意：若一个视图依赖于多个基本表，则一次修改该视图只能变动一个基本表的数据。例如：基于学生表和成绩表创建视图stu_score_view2，若同时修改成绩和姓名将会报错。--对创建时带有“WITH CHECK OPTION”的检查视图，通过视图执行的所有数据修改语句必须符合视图定义中where子句设置的条件。例题：通过视图jsj_stu_view，尝试将“李牧”的系别编号改为“002”，注意查看执行结果，说明能否成功修改？update jsj_stu_view set d_no='002' where s_name='李牧';答：修改失败。提示：[Err] 1369 - CHECK OPTION failed 'coursedb.jsj_stu_view'--删除数据：使用DELETE语句可以通过视图删除基本表的数据。
--【例】删除jsj_xs中李牧同学的记录。delete from jsj_xs where s_name='李牧';--注意：如果视图引用多个表时，无法用DELETE命令删除数据。

（5）修改视图

--使用ALTER语句可以对已有视图的定义进行修改。--语法格式: （与create view类似）ALTER VIEW 视图名 AS select 表名 where <条件>;--【例】将jsj_xs视图修改为只包含001系(计算机系)学生的学号、姓名和系别三列。alter view jsj_xs asselect s_no,s_name,d_no from studentswhere d_no='001';--由于视图保存的仅是其定义语句，不存储表数据，所以也可以先删除视图，然后重新创建，或者用“create or replace”创建新视图，替换原有视图。

（6）删除视图

--语法格式：DROP VIEW [IF EXISTS]视图名 [, 视图名] ...[RESTRICT | CASCADE]提示：其中，view_name是视图名，声明了IF EXISTS，若视图不存在的话，也不会出现错误信息。--例如：drop view cs_xs;  将删除视图cs_xs。--使用DROP VIEW一次可删除多个视图

1.46 索引

【内容提要】：
索引是一种特殊的数据库结构，可以用来加快数据库的查询速度。是提高数据库性能的重要方式。其本质为数据库表中字段值的复制，该字段值称为索引的关键字。MySQL在检索表中的数据时，先按索引关键字在索引中查找，如果能找到，则直接定位到数据所在的页；如果没有找到，则只能全表扫描查找数据。MySQL默认使用B+树存储索引，MyISAM引擎表的数据文件和索引文件是分开存储的（*.MYD和*.MYI文件），InnoDB引擎表的数据和索引文件在同一文件中（*.ibd），为聚簇索引；InnoDB表的索引(B+树)的每个非叶子节点存储索引值，叶子节点存储索引和索引对应的数据。
MySQL的聚簇索引与其他数据库管理系统不同，即便是创建一个没有设置主键的InnoDB表，MySQL也会自动为其创建一个“隐式”的主键。对InnoDB表而言，必有聚簇索引（且只有一个）。

【按功能划分】：主键索引、普通索引、唯一索引、全文索引；
【按列数划分】：单列索引、多列索引；
【按物理存储方式划分】：聚簇索引和非聚簇索引（也称辅助索引或二级索引）等。

【创建索引的方法】：
1.创建表的同时创建索引
2.给已存在的表创建索引（使用create index 或者 alter table语句）

--索引：类似于书目录
--优点：加快查询速度
--缺点：创建索引会占用磁盘空间
--前提：创建索引的列必须是where子句的条件，where语句后的条件可以是<, >, =, between, in ，但不要使用 not in和<>（不等于）；若有like条件，'%xxx'不能使用，'xxx%'可以使用。--创建索引create index 索引名 on 表名(字段名);例子：给sc表的sid字段创建索引create index index_sc_sid on sc(sid);给order_1表创建唯一索引（关键字：unique）create unique index index_order1_orderid on order_1(order_id(6));--查看索引show index from 表名;例子：查看sc表的索引show index from sc;查看order_1表的索引show index from order_1;--删除索引drop index 索引名 on 表名;例子：drop index index_order1_orderid on order_1;删除sc表的sid字段的索引drop index index_sc_sid on sc;

--1.在创建表的同时创建索引语法格式：create table 表名(字段名1 数据类型 [约束条件],…[其他约束条件],…[ unique | fulltext ]  index  [索引名] (字段名 [(长度)] [ asc | desc ] )) engine=存储引擎类型 default charset=字符集类型例子：创建一个表名为table1的表，在表的ID字段上创建一个普通索引。（不指定索引类型即为普通索引）create table table1(id int,name varchar(8),sex boolean,index(id));--2.在已有的表上创建索引。语法格式：create  [unique|full text] index 索引名  on 表名(字段名[(长度)] [asc|desc]);例题：在table1的name列上创建一个名为uni_name_index的唯一索引。create unique index uni_name_index on table1(name);--3.对已有的表使用Alter table 语句创建索引语法格式：Alter table 表名 add [unique|full text] index 索引名 (字段名 [(长度)] [asc|desc]);例题：在table3的identitycard列上创建一个名为uni_idcard_index的唯一索引。alter table table3 add unique index uni_idcard_index(identitycard);

实例验证：索引和前缀索引

--MySQL中，对于BLOB，TEXT，或者很长的VARCHAR类型的列，必须使用前缀索引，因为MySQL不允许索引这些列的完整长度。1、创建test表，表结构如下图：mysql> create table test(id int auto_increment primary key, randnum         varchar(255) not null);2、给test表插入数据，先插入10行（1亿以内的随机整数）。insert into test(randnum) values(floor(1000000000*rand()+1));insert into test(randnum) values(floor(1000000000*rand()+2));insert into test(randnum) values(floor(1000000000*rand()+3));……

今天的“实例验证 索引”题目中，截一张插入千万条记录后的运行截图：

数据库mysql的基本操作命令（全）相关推荐

1. 云图说｜云数据库MySQL内核小版本升级全攻略

   华为云有新的内核小版本发布时,您可以在"实例管理"页面看到内核小版本升级提示,具体操作方法及注意事项"云图说"来为您详解: 点击"了解更多" ...

2. mysql 删除时间一个星期_15天快速学习 数据库Mysql 基础操作命令（第一章）

   简言 你还在为不了解不会操作MySQL数据库而苦恼吗? 还为面对冗繁的数据不知怎么提取而愤懑吗? 分享快速学习MySQL及基础操作命令 那就利用闲暇时间和我一起掌握一门MySQL数据库语言操作吧! 入 ...

3. MySQL（1）数据库介绍，配置MySQL的tab补全

   文章目录 一.数据库的基本概念 1.1 使用数据库的必要性 1.2 数据库的概念 1.2.1 数据(Data) 1.2.2 表 1.2.3 数据库 1.2.4 数据库管理系统(DBMS) 1.2.5 ...

4. mysql dump hbase_mysqldump导出全数据库

   mysql备份与恢复 导出所有数据库 mysqldump -q --single-transaction -A >all.sql 导出某几个数据库 mysqldump -q --single-t ...

5. Python3 数据库(MySQL/MongoDB/Redis)

   Python3 数据库(MySQL/MongoDB/Redis) 本文由 Luzhuo 编写,转发请保留该信息. 原文: https://blog.csdn.net/Rozol/article/det ...

6. Mysql常用基础操作命令及数据操作命令一览

   一.MySQL关于表基础命令 1.1 表的创建 语法: create table if not exists 表名 ( 字段名 数据类型(null | not null,default | auto_ ...

7. 数据库MySQL入门-上

   文章目录 第1章 数据库 1.1 数据库概述 1.2 数据库表 1.3 表数据 第2章 MySql数据库 2.1 MySql安装 2.2 登录MySQL数据库 2.3 使用MySQL图形化开发工具 2 ...

8. Mac操作数据库Mysql知识点备忘录

   目录 Mac安装Ubuntu启动Mysql Mac安装Mysql CenterOS Mac Mysql 8和5的密码插件区别 介绍 基础命令操作数据库 远程连接 数据库操作命令 表操作命令 数据操作命 ...

9. 数据库MYSQL学习系列三

   数据库MYSQL学习系列三 三．MYSQL事务与存储引擎 3.1-数据库事务 什么是事务 一系列有序的数据库操作: o要么全部成功 o要么全部回退到操作前的状态 o中间状态对其他连接不可见 事务的 ...

最新文章

1. 掩码语言模型(Masked Language Model)mlm
2. js 变量提升 和函数提升
3. CUDA系列学习（一）An Introduction to GPU and CUDA
4. 喂，你连用户模型都不懂还当产品？来，妹纸我手把手教你
5. 《中国人工智能学会通讯》——6.25 日落的教训
6. GDKOI2018发烧记
7. mysql 的数据备份_MySQL 数据备份与还原
8. 举例说明string类和stringbuffer类的区别_String,StringBuilder,StringBuffer的区别
9. 小男孩与苹果树(翻译)（06年10月）
10. 第四季-专题20-SPI驱动程序设计
11. 三星s9 android p内测,三星国行Galaxy S9/S9+用户安卓9.0内测：更新One UI
12. JBoss Tools 4.5.3.Final安装及下载
13. win10 永久关闭自动更新
14. 老徐解析小程序：微小程客户系统讲解
15. 简普科技Q3财报解读：业绩超过预期之后的更多确定性
16. 分布式事务解决方案：7种常见解决方案汇总
17. docker run 命令的 -i -t -d选项的作用
18. java fmail发送邮件_【已实测通过】JavaMail常用的几种邮件发送方式
19. 提交模式窗口后，刷新父窗口数据+获取frameset中各模块中数据
20. chrome 有哪些有用的插件

热门文章

1. 小型水库水雨情监测预警自动测报平台 辅助水利在线监测水库水位+雨量
2. 浏览器自带开发工具你知道多少？
3. 平生事，此时凝睇，谁会凭栏意！（2）
4. syntax error: unexpected :=解决方案
5. 最简单的改变字体大小代码
6. 设计师必备！免费下载 PSD 素材的32个网站
7. 认识 BASH Shell
8. Redis-设置过期时间及淘汰策略
9. 一元函数对象、一元谓词、二元函数对象、二元谓词
10. 电调板维修之更换atmega8a主控芯片