06.sqlite3学习——DQL（数据查询）（全）

目录

SQLite------DQL（数据查询）

数据集

select语句

条件查询

比较

确定范围

确定集合

like

查询记录

查询不重复的记录

排序和限制

排序

限制

聚合

聚合函数

语法

[SQLite Group By详解](#SQLite Group By详解)

语法

实例

[SQLite Having 子句](#SQLite Having 子句)

语法

实例

多表查询

表连接

SQLite中的Join

[内连接 - INNER JOIN](#内连接 - INNER JOIN)

[外连接 - OUTER JOIN](#外连接 - OUTER JOIN)

[交叉连接 - CROSS JOIN](#交叉连接 - CROSS JOIN)

[Distinct 关键字](#Distinct 关键字)

语法

实例

---

SQLite------DQL（数据查询）

数据集

本节DQL所有操作的范围都在以下数据集中

CREATE TABLE student(
    sno VARCHAR(20) PRIMARY KEY ,
    sname VARCHAR(20),
    ssex VARCHAR(20),
    sbirthday DATETIME ,
    class VARCHAR(20) 
);
CREATE TABLE course(
    cno VARCHAR(20) PRIMARY KEY ,
    cname VARCHAR(20) NOT NULL ,
    tno VARCHAR(20) NOT NULL 
);
CREATE TABLE score(
    id INT PRIMARY KEY,
    sno VARCHAR(20) NOT NULL,
    cno VARCHAR(20) NOT NULL,
    degree DECIMAL(4,1)
);
CREATE TABLE teacher(
    tno VARCHAR(20) PRIMARY KEY NOT NULL,
    tname VARCHAR(20) NOT NULL ,
    tsex VARCHAR(20) NOT NULL,
    tbirthday DATETIME ,
    prof VARCHAR(20) ,
    depart VARCHAR(20)
);
INSERT INTO student VALUES
('108','曾华','男','1977-09-01','95033'),
('105','匡明','男','1977-09-01','95031'),
('107','王丽','女','1977-09-01','95033'),
('101','李军','男','1977-09-01','95033'),
('109','王芳','女','1977-09-01','95031'),
('103','陆君','男','1977-09-01','95031');
INSERT INTO course VALUES
('3-105','计算机导论','825'),
('3-245','操作系统','804'),
('6-166','数字电路','856'),
('9-888','高等数学','831');
SELECT * FROM score;
INSERT INTO score(sno,cno,degree) VALUES
('103','3-245','86'),
('105','3-245','75'),
('109','3-245','68'),
('103','3-105','92'),
('105','3-105','88'),
('109','3-105','76'),
('101','3-105','64'),
('107','3-105','91'),
('108','3-105','78'),
('101','6-166','85'),
('107','6-166','79'),
('108','6-166','81');
INSERT INTO teacher VALUES
('804','李诚','男','1958-12-02','副教授','计算机系'),
('856','张旭','男','1969-03-12','讲师','电子工程系'),
('825','王萍','女','1972-05-05','助教','计算机系'),
('831','刘冰','女','1977-08-14','助教','电子工程系');

我们首先创建一个数据库test.db

通过数据集创建所有表

course：

score：

student：

teacher：

select语句

条件查询

比较

确定范围

练习：查询Score表中成绩在60到80之间的所有记录。

select * from score where degree>60 and degree

确定集合

练习：查询Score表中成绩为85，86或88的记录。

select * from score where degree in (85,86,88);

like

练习：查询Student表中"95031"班或性别为"女"的同学记录。

select * from student where class like '95031' or ssex like '女';

查询记录

• select*from 表名 [where 条件];

如果想要查看表中所有信息

• select field1,field2,...fieldn... from 表名 [where 条件];

如果想要查看某几列信息

通过条件where可以进行数据筛选

练习

查询Student表中的所有记录的Sname、Ssex和Class列。

select sname,ssex,class from student;

查询不重复的记录

• select distinct 字段 from 表名;
  • select distinct name from students;//查询名字不相同的学生;
  • select distinct name,age from students;//查询名字和年龄同时不同的学生
• distinct必须放在最开头
• distinct只能使用需要去重的字段进行操作
• distinct去重多个字段时，含义是：几个字段 同时重复 时才会被 过滤。

练习：查询教师所有的单位即不重复的Depart列。

select distinct depart from teacher;

排序和限制

注意：在sql中我们经常会用到排序，当字段是int或者其它数值类型的时候对该数值进行排序，默认是从大到小进行排序，这个是没什么问题的

但是对varchar类型的字段进行排序的时候，就要谨慎使用，它是按照单个字符的ASCII码值逐个比较排序的。

可参考：

SQL中varchar类型排序的规则

排序

• desc 降序排列，asc 升序排列
• order by 后面可以跟多个不同的排序字段，每个排序字段都可以有不同的排序顺序。
• 如果排序字段的值一样，则相同的字段按照第二个排序字段进行排序。
• 如果只有一个排序字段，则字段相同的记录将会无序排列。

语法

select * from 表名 [where 条件] [ order by field1 [desc/asc],field2 [desc/asc]... ];

例：select *from student order by age desc;//查询学生表并按年龄降序排列。

练习：以Cno升序、Degree降序查询Score表的所有记录。

select * from score order by cno asc , degree desc;

限制

语法：select ... [limit 起始偏移量,行数];

例：

select * from student order by mark desc limit 5;//取出成绩前五名的学生(省略了起始偏移量，此时默认为0)

注：默认情况下，起始偏移量为0，只写记录行数就可以。

练习：查询Score表中的最高分的学生学号和课程号。

select * from score order by degree desc limit 1;

下面这个使用的连接查询

select max(degree) from score   #先写出score的最高分
select * from score where degree = (select max(degree) from score);
select sno,cno from score where degree = (select max(degree) from score);

聚合

聚合函数

• 聚合函数 count(),求数据表的行数

select count(*/字段名) from 数据表

• 聚合函数 max(),求某列的最大数值

select max(字段名）from 数据表

• 聚合函数min(),求某列的最小值

select main(字段名） from 数据表

• 聚合函数sum(),对数据表的某列进行求和操作

select sum(字段名) from 数据表

• 聚合函数avg(),对数据表的某列进行求平均值操作

select avg(字段名） from 数据表

语法

select 字段 聚合函数 from 表名 [where 条件] [group by field1,field2...] [with rollup] [having 条件];

• group by语法可以根据给定数据列的每个成员对查询结果进行分组统计，最终得到一个分组汇总表

group by得到的数据，每一个数值只显示一行，需要有意义的使用。

如我们要查询sorce表中每个学号（sno）的成绩个数：

SELECT sno,count(sno) FROM score GROUP by sno;

• 将where子句与group by子句一起使用分组查询可以在形成组和计算列函数之前具有消除非限定行的标准where子句。
• 必须在group by子句之前指定where子句
• group by子句之后使用having子句可应用限定条件进行分组，对分组之后的数据进行筛选，以便系统仅对满足条件的组返回结果。
• WHERE过滤行，HAVING过滤组
• 分组查询的是指先将数据进行分组，然后从每个组中查询数据，将每个组查询的数据合成一个新的表进行显示

练习1：查询"95031"班的学生人数

select count(*) from student where class = '95031' group by class;

练习2：查询每门课的平均成绩

select count(*) from student where class = '95031' group by class;

select cno,count(*),avg(degree) from score group by cno; 多条查询

SQLite Group By详解

SQLite 的 GROUP BY 子句用于与 SELECT 语句一起使用，来对相同的数据进行分组。

在 SELECT 语句中，GROUP BY 子句放在 WHERE 子句之后，放在 ORDER BY 子句之前。

语法

下面给出了 GROUP BY 子句的基本语法。GROUP BY 子句必须放在 WHERE 子句中的条件之后，必须放在 ORDER BY 子句之前。

SELECT column-list
FROM table_name
WHERE [ conditions ]
GROUP BY column1, column2....columnN
ORDER BY column1, column2....columnN

您可以在 GROUP BY 子句中使用多个列。确保您使用的分组列在列清单中。

实例

假设 COMPANY 表有以下记录：

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

如果您想了解每个客户的工资总额，则可使用 GROUP BY 查询，如下所示：

sqlite> SELECT NAME, SUM(SALARY) FROM COMPANY GROUP BY NAME;

这将产生以下结果：

NAME        SUM(SALARY)
----------  -----------
Allen       15000.0
David       85000.0
James       10000.0
Kim         45000.0
Mark        65000.0
Paul        20000.0
Teddy       20000.0

现在，让我们使用下面的 INSERT 语句在 COMPANY 表中另外创建三个记录：

INSERT INTO COMPANY VALUES (8, 'Paul', 24, 'Houston', 20000.00 );
INSERT INTO COMPANY VALUES (9, 'James', 44, 'Norway', 5000.00 );
INSERT INTO COMPANY VALUES (10, 'James', 45, 'Texas', 5000.00 );

现在，我们的表具有重复名称的记录，如下所示：

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0
8           Paul        24          Houston     20000.0
9           James       44          Norway      5000.0
10          James       45          Texas       5000.0

让我们用同样的 GROUP BY 语句来对所有记录按 NAME 列进行分组，如下所示：

sqlite> SELECT NAME, SUM(SALARY) FROM COMPANY GROUP BY NAME ORDER BY NAME;

这将产生以下结果：

NAME        SUM(SALARY)
----------  -----------
Allen       15000
David       85000
James       20000
Kim         45000
Mark        65000
Paul        40000
Teddy       20000

让我们把 ORDER BY 子句与 GROUP BY 子句一起使用，如下所示：

sqlite>  SELECT NAME, SUM(SALARY) 
         FROM COMPANY GROUP BY NAME ORDER BY NAME DESC;

这将产生以下结果：

NAME        SUM(SALARY)
----------  -----------
Teddy       20000
Paul        40000
Mark        65000
Kim         45000
James       20000
David       85000
Allen       15000

SQLite Having 子句

HAVING 子句允许指定条件来过滤将出现在最终结果中的分组结果。

WHERE 子句在所选列上设置条件，而 HAVING 子句则在由 GROUP BY 子句创建的分组上设置条件。

语法

下面是 HAVING 子句在 SELECT 查询中的位置：

SELECT
FROM
WHERE
GROUP BY
HAVING
ORDER BY

在一个查询中，HAVING 子句必须放在 GROUP BY 子句之后，必须放在 ORDER BY 子句之前。下面是包含 HAVING 子句的 SELECT 语句的语法：

SELECT column1, column2
FROM table1, table2
WHERE [ conditions ]
GROUP BY column1, column2
HAVING [ conditions ]
ORDER BY column1, column2

实例

假设 COMPANY 表有以下记录：

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0
8           Paul        24          Houston     20000.0
9           James       44          Norway      5000.0
10          James       45          Texas       5000.0

下面是一个实例，它将显示名称计数小于 2 的所有记录：

sqlite > SELECT * FROM COMPANY GROUP BY name HAVING count(name) < 2;

这将产生以下结果：

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
2           Allen       25          Texas       15000
5           David       27          Texas       85000
6           Kim         22          South-Hall  45000
4           Mark        25          Rich-Mond   65000
3           Teddy       23          Norway      20000

下面是一个实例，它将显示名称计数大于 2 的所有记录：

sqlite > SELECT * FROM COMPANY GROUP BY name HAVING count(name) > 2;

这将产生以下结果：

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
10          James       45          Texas       5000

多表查询

多表查询就是将一个表的查询作为条件，来支撑下一表的查询

练习1：查询考计算机导论的学生成绩

 select sno,degree from score where cno = (select cno from course where cname = '计算机导论');

练习2：查询李诚老师教的课程名称

select cname from course where tno = (select tno from teacher where tname = '李诚');

练习3：查询和学号为108的同学同年出生的所有学生的Sno、Sname和Sbirthday列。

 select sno,sname,sbirthday from student where sbirthday = (select sbirthday from student where sno = '108');

练习4：查询选修"3-105"课程的成绩高于"109"号同学成绩的所有同学的记录。

select sno,degree from score where degree > (select degree from score where sno = '109' and cno = '3-105');

练习5：查询选修某课程的同学人数多于5人的教师姓名。

select cno,count(*) from score group by cno having count(*)>=5;   #找出课程编号

select tname from teacher where tno = (select tno from course where cno = (select cno from score group by cno having count(*)>=5));

练习6：查询出"计算机系"教师所教课程的成绩表。

select tno,tname from teacher where depart = '计算机系'   #查出教师编号
select cno from course where tno in (select tno from teacher where depart = '计算机系');  #查出课程编号
select sno,cno,degree from score where cno in (select cno from course where tno in (select tno from teacher where depart = '计算机系'));

表连接

多表查询是指将一个表的查询的结果作为另一个表的条件，再去查询。

表连接是指将两个表的信息连接在一起作为查询的条件，再去查询。

表连接一般分为四种方式：内连接、外连接、全连接（sqlite不支持）和交叉连接

SQLite中的Join

SQLite 的 Join 子句用于结合两个或多个数据库中表的记录。JOIN 是一种通过共同值来结合两个表中字段的手段。

SQL 定义了三种主要类型的连接：

• 交叉连接 - CROSS JOIN
• 内连接 - INNER JOIN
• 外连接 - OUTER JOIN

内连接 - INNER JOIN

内连接（INNER JOIN）根据连接谓词结合两个表（table1 和 table2）的列值来创建一个新的结果表。查询会把 table1 中的每一行与 table2 中的每一行进行比较，找到所有满足连接谓词的行的匹配对。当满足连接谓词时，A 和 B 行的每个匹配对的列值会合并成一个结果行。

内连接（INNER JOIN）是最常见的连接类型，是默认的连接类型。INNER 关键字是可选的。

下面是内连接（INNER JOIN）的语法：

SELECT ... FROM table1 [INNER] JOIN table2 ON conditional_expression ...

为了避免冗余，并保持较短的措辞，可以使用 USING 表达式声明内连接（INNER JOIN）条件。这个表达式指定一个或多个列的列表：

SELECT ... FROM table1 JOIN table2 USING ( column1 ,... ) ...

自然连接（NATURAL JOIN）类似于 JOIN...USING，只是它会自动测试存在两个表中的每一列的值之间相等值：

SELECT ... FROM table1 NATURAL JOIN table2...

练习1：查询所有学生的Sname、Cname和Degree列。

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

练习2：查询最高分同学的Sname ,Sno、Cno和Degree列。

select score.sno,cno,degree from student
join score on student.sno = score.sno
where degree = (select max(degree) from score);

练习3：查询每个学生编号的课程、课程编号、课程成绩和课程老师

select student.sno,course.cname,course.cno,score.degree,teacher.tname from student 
join score on student.sno = score.sno 
join course on course.cno = score.cno
join teacher on teacher.tno = course.tno;

外连接 - OUTER JOIN

外连接（OUTER JOIN）是内连接（INNER JOIN）的扩展。虽然 SQL 标准定义了三种类型的外连接：LEFT、RIGHT、FULL，但 SQLite 只支持 左外连接（LEFT OUTER JOIN）。

外连接（OUTER JOIN）声明条件的方法与内连接（INNER JOIN）是相同的，使用 ON、USING 或 NATURAL 关键字来表达。最初的结果表以相同的方式进行计算。一旦主连接计算完成，外连接（OUTER JOIN）将从一个或两个表中任何未连接的行合并进来，外连接的列使用 NULL 值，将它们附加到结果表中。

下面是左外连接（LEFT OUTER JOIN）的语法：

SELECT ... FROM table1 LEFT OUTER JOIN table2 ON conditional_expression ...

为了避免冗余，并保持较短的措辞，可以使用 USING 表达式声明外连接（OUTER JOIN）条件。这个表达式指定一个或多个列的列表：

SELECT ... FROM table1 LEFT OUTER JOIN table2 USING ( column1 ,... ) ...

我们假设有两个表 COMPANY 和 DEPARTMENT。

下面的 SQLite 语句创建一个新的表 COMPANY，并增加了五列，其中 ID、NAME 和 AGE 三列指定不接受 NULL 值：

CREATE TABLE DEPARTMENT(
ID INT PRIMARY KEY      NOT NULL,
DEPT           CHAR(50) NOT NULL,
EMP_ID         INT      NOT NULL
);

现在让我们假设 COMPANY 表的记录列表如下：

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

另一个表是 DEPARTMENT，定义如下：

CREATE TABLE DEPARTMENT(
   ID INT PRIMARY KEY      NOT NULL,
   DEPT           CHAR(50) NOT NULL,
   EMP_ID         INT      NOT NULL
);

下面是填充 DEPARTMENT 表的 INSERT 语句：

INSERT INTO DEPARTMENT (ID, DEPT, EMP_ID)
VALUES (1, 'IT Billing', 1 );

INSERT INTO DEPARTMENT (ID, DEPT, EMP_ID)
VALUES (2, 'Engineering', 2 );

INSERT INTO DEPARTMENT (ID, DEPT, EMP_ID)
VALUES (3, 'Finance', 7 );

最后，我们在 DEPARTMENT 表中有下列的记录列表：

ID          DEPT        EMP_ID
----------  ----------  ----------
1           IT Billing  1
2           Engineerin  2
3           Finance     7

基于上面的表，我们可以写一个外连接（OUTER JOIN），如下所示：

sqlite> SELECT EMP_ID, NAME, DEPT FROM COMPANY LEFT OUTER JOIN DEPARTMENT
        ON COMPANY.ID = DEPARTMENT.EMP_ID;

上面的查询会产生以下结果：

EMP_ID      NAME        DEPT
----------  ----------  ----------
1           Paul        IT Billing
2           Allen       Engineerin
NULL        Teddy       NULL
NULL        Mark        NULL
NULL        David       NULL
NULL        Kim         NULL
7           James       Finance

交叉连接 - CROSS JOIN

交叉连接（CROSS JOIN）把第一个表的每一行与第二个表的每一行进行匹配。如果两个输入表分别有 x 和 y 行，则结果表有 x*y 行。由于交叉连接（CROSS JOIN）有可能产生非常大的表，使用时必须谨慎，只在适当的时候使用它们。（在实际开发中很少用）

交叉连接的操作，它们都返回被连接的两个表所有数据行的笛卡尔积，返回到的数据行数等于第一个表中符合查询条件的数据行数乘以第二个表中符合查询条件的数据行数。

下面是交叉连接（CROSS JOIN）的语法：

SELECT ... FROM table1 CROSS JOIN table2 ...

基于上面的表，我们可以写一个交叉连接（CROSS JOIN），如下所示：

sqlite> SELECT EMP_ID, NAME, DEPT FROM COMPANY CROSS JOIN DEPARTMENT;

上面的查询会产生以下结果：

EMP_ID      NAME        DEPT
----------  ----------  ----------
1           Paul        IT Billing
2           Paul        Engineerin
7           Paul        Finance
1           Allen       IT Billing
2           Allen       Engineerin
7           Allen       Finance
1           Teddy       IT Billing
2           Teddy       Engineerin
7           Teddy       Finance
1           Mark        IT Billing
2           Mark        Engineerin
7           Mark        Finance
1           David       IT Billing
2           David       Engineerin
7           David       Finance
1           Kim         IT Billing
2           Kim         Engineerin
7           Kim         Finance
1           James       IT Billing
2           James       Engineerin
7           James       Finance

Distinct 关键字

SQLite 的 DISTINCT 关键字与 SELECT 语句一起使用，来消除所有重复的记录，并只获取唯一一次记录。

有可能出现一种情况，在一个表中有多个重复的记录。当提取这样的记录时，DISTINCT 关键字就显得特别有意义，它只获取唯一一次记录，而不是获取重复记录。

语法

用于消除重复记录的 DISTINCT 关键字的基本语法如下：

SELECT DISTINCT column1, column2,.....columnN 
FROM table_name
WHERE [condition]

实例

假设 COMPANY 表有以下记录：

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0
8           Paul        24          Houston     20000.0
9           James       44          Norway      5000.0
10          James       45          Texas       5000.0

首先，让我们来看看下面的 SELECT 查询，它将返回重复的工资记录：

sqlite> SELECT name FROM COMPANY;

这将产生以下结果：

NAME
----------
Paul
Allen
Teddy
Mark
David
Kim
James
Paul
James
James

现在，让我们在上述的 SELECT 查询中使用 DISTINCT关键字：

sqlite> SELECT DISTINCT name FROM COMPANY;

这将产生以下结果，没有任何重复的条目：

NAME
----------
Paul
Allen
Teddy
Mark
David
Kim
James