子查询 订阅
子查询是一种常用计算机语言SELECT-SQL语言中嵌套查询下层的程序模块。当一个查询是另一个查询的条件时,称之为子查询。 展开全文
子查询是一种常用计算机语言SELECT-SQL语言中嵌套查询下层的程序模块。当一个查询是另一个查询的条件时,称之为子查询。
信息
外文名
Sub Query
命    令
WHERE子句中
中文名
子查询
语    言
SELECT-SQL
子查询定义概念
在SQL语言中,一个SELECT-FROM-WHERE语句称为一个查询块。当获得一个查询的答案需要多个步骤的操作,首先必须创建一个查询来确定用户不知道但包含在数据库中的值,将一个查询块嵌套在另一个查询块的WHERE字句或HAVING短语的条件中查询块称为子查询或内层查询。上层的查询块曾为父查询或外层查询。子查询的结果作为输入传递回“父查询”或“外部查询”。父查询将这个值结合到计算中,以便确定最后的输出。SQL语言允许多层嵌套查询,即一个子查询中还可以嵌套其他子查询。以层层嵌套的方式来构造程序正是SQL中"结构化"的含义所在。 [1]  子查询是本质上就是一个完整 的SELECT 语句,它可以使一个 SELECT、SELECT...INTO 语句、INSERT...INTO 语句、DELETE 语句、或 UPDATE 语句或嵌套在另一子查询中。子查询的输出可以包括一个单独的值(单行子查询)、几行值(多行子查询)、或者多列数据(多列子查询)。
收起全文
精华内容
下载资源
问答
  • MySQL 之子查询
    千次阅读
    2021-01-27 17:01:12

    定义:

    子查询指一个查询语句嵌套在另一个查询语句内部的查询,这个特性从 MySQL4.1 开始引入,在 SELECT 子句中先计算子查询,子查询结果作为外层另一个查询的过滤条件,查询可以基于一个表或者多个表。

    子查询中常用的操作符有 ANY(SOME)、ALL、IN 和 EXISTS。

    子查询可以添加到 SELECT、UPDATE 和 DELETE 语句中,而且可以进行多层嵌套。子查询也可以使用比较运算符,如“”、“>=”、“!=”等。

    子查询常用的运算符:

    1) IN子查询

    结合关键字 IN 所使用的子查询主要用于判断一个给定值是否存在于子查询的结果集中。其语法格式为:

    [NOT] IN

    语法说明如下。

    :用于指定表达式。当表达式与子查询返回的结果集中的某个值相等时,返回 TRUE,否则返回 FALSE;若使用关键字 NOT,则返回的值正好相反。

    :用于指定子查询。这里的子查询只能返回一列数据。对于比较复杂的查询要求,可以使用 SELECT 语句实现子查询的多层嵌套。

    2) 比较运算符子查询

    比较运算符所使用的子查询主要用于对表达式的值和子查询返回的值进行比较运算。其语法格式为:

    {= | < | > | >= | <= | <=> | < > | != }

    { ALL | SOME | ANY}

    语法说明如下。

    :用于指定子查询。

    :用于指定要进行比较的表达式。

    ALL、SOME 和 ANY:可选项。用于指定

    更多相关内容
  • 子查询

    千次阅读 多人点赞 2019-05-19 10:46:40
    常见的子查询包括:WHERE子查询,FROM子查询,HAVING子查询,EXISTS子查询子查询必须使用小括号括起来。 WHERE子查询 案例 查询出低于平均工资的雇员信息(子查询返回的结果集是单行单列) SELECT * FROM emp ...

    子查询就是将一个查询的结果作为另一个查询的数据来源或判断条件的查询。
    常见的子查询包括:WHERE子查询,FROM子查询,HAVING子查询,EXISTS子查询,子查询必须使用小括号括起来。

    WHERE子查询

    案例
    查询出低于平均工资的雇员信息(子查询返回的结果集是单行单列)

    SELECT * FROM emp WHERE sal<(SELECT AVG(sal) FROM emp);
    

    在这里插入图片描述
    查询出公司最早入职的雇员信息

    SELECT * FROM emp WHERE hiredate=(SELECT MIN(hiredate) FROM emp);
    

    在这里插入图片描述
    查询出与SCOTT从事统一工作且工资相同的雇员信息
    若子查询中返回的是单行多列的结果集
    主查询中的条件判断字段的顺序要与子查询中需要查询的字段顺序保持一致

    SELECT * FROM emp WHERE (job,sal)=
    (SELECT job,sal FROM emp WHERE ename='SCOTT')
     AND ename<>'SCOTT'; 
    

    在这里插入图片描述
    查询出与经理职位工资相同的员工的工资
    子查询中返回的结果集是多行单列

    SELECT * FROM emp WHERE sal IN(SELECT sal FROM emp WHERE job='MANAGER')
    AND job<>'MANAGER';
    

    ANY 、ALL关键字
    ANY表示范围内任意一个,ALL表示范围内全部
    查询出薪资比经理的最高薪资低的员工信息(即小于任意一个经理的薪资)

    SELECT * FROM emp WHERE sal<ANY(SELECT sal FROM emp WHERE job='MANAGER');
    

    在这里插入图片描述
    查询出比经理的最低薪资低的员工信息(即小于所有的经理的薪资)

    SELECT * FROM emp WHERE sal<ALL(SELECT sal FROM emp WHERE job='MANAGER');
    

    在这里插入图片描述
    查询出薪资排名第三的雇员的信息

    SELECT * FROM emp
     WHERE sal=(SELECT MAX(sal) FROM emp WHERE sal<(SELECT max(sal) FROM emp WHERE sal<(SELECT MAX(sal) FROM emp)));
    

    在这里插入图片描述

    HAVING子查询

    HAVING子查询指的是分组过滤条件下的子查询,在HAVING子句中。
    案例
    查询出平均薪资高于所有员工平均薪资的职位的名称,以及职位的人数,以及这些职位的平均薪资

    SELECT job,COUNT(*),AVG(sal) FROM emp
    GROUP BY job HAVING AVG(sal)>
    (SELECT AVG(sal) FROM emp);
    

    在这里插入图片描述
    查询出平均薪资最高的职位的名称和该职位的平均薪资

    SELECT job,AVG(sal) FROM emp
    GROUP BY job HAVING AVG(sal) = 
    (SELECT MAX(AVG(sal)) FROM emp GROUP BY job);
    

    在这里插入图片描述

    FROM子查询

    FROM子查询的数据来源是另一个查询的结果相当于一张临时数据表,
    通常为子查询定义别名,如果要用子查询中的字段使用别名.字段名调用,
    返回的一般是多行多列的结果集
    案例
    查询平均工资高于2000的职位名称以及该职位的平均工资

    SELECT job,avgsal
     FROM (SELECT job,AVG(sal) AS avgsal FROM emp GROUP BY job)temp
     WHERE temp.avgsal>2000;
    

    在这里插入图片描述
    查询出有佣金并且薪资高于佣金的雇员的信息

    SELECT * FROM (SELECT * FROM emp WHERE comm IS NOT NULL)
    WHERE sal>comm;
    

    在这里插入图片描述
    查询各岗位的最高薪水、最低薪水,要求只统计薪水>1000的;

    SELECT job,MAX(sal),MIN(sal)
     FROM (SELECT * FROM emp WHERE sal>1000)
     GROUP BY job;
    

    查询各部门的平均薪水及部门编号,只统计薪水>2000的

    SELECT AVG(sal),deptno
     FROM (SELECT * FROM emp WHERE sal>2000)
      GROUP BY deptno;
    

    在这里插入图片描述
    查询各部门的平均薪水及部门编号,要求只有员工姓名包含’A’的才参与统计,只列出平均薪水>1500的,按照平均薪水降序排列

    SELECT AVG(sal) avgsal,deptno FROM
     (SELECT * FROM emp WHERE ename LIKE '%A%')
     GROUP BY deptno HAVING AVG(sal) > 1500 ORDER BY avgsal DESC;
    

    在这里插入图片描述
    查询最高薪水的员工信息

    SELECT * FROM emp WHERE sal=(SELECT MAX(sal) FROM emp);
    

    在这里插入图片描述
    查询薪水大于所在部门平均薪水的员工信息

    SELECT * FROM emp e,
     (SELECT deptno,AVG(sal) avgsal 
     FROM emp GROUP BY deptno)t     
     WHERE e.deptno=t.deptno AND sal>avgsal;
    

    在这里插入图片描述
    查询各部门最高薪水的员工信息

    SELECT * FROM emp e,
    (SELECT deptno,MAX(sal) maxsal FROM emp GROUP BY deptno) t 
     WHERE e.deptno=t.deptno AND e.sal=t.maxsal;
    

    在这里插入图片描述

    EXISTS子查询

    EXISTS子查询的特征:将主查询中的数据带到子查询中验证,若验证成功则返回TRUE,验证失败返回FALSE;当主查询接收到TRUE时,该数据显示,若接收到FALSE,该数据不显示。
    案例
    查询出有部门的雇员信息

    SELECT * FROM emp e WHERE EXISTS (SELECT * FROM dept d
     WHERE e.deptno=d.deptno);
    

    在这里插入图片描述
    查询出没有佣金的雇员的信息

    SELECT * FROM emp e WHERE EXISTS(
     SELECT * FROM emp p WHERE e.comm=p.comm);
    

    在这里插入图片描述

    展开全文
  • 什么是子查询? 使用子查询解决问题:谁的工资比SCOTT高? 子查询的语法 子查询(内查询)在主查询之间一次执行完成。\color{red}{子查询(内查询)在主查询之间一次执行完成。}子查询(内查询)在主查询...

    什么是子查询?

    使用子查询解决问题:谁的工资比SCOTT高?
    在这里插入图片描述

    子查询的语法

    在这里插入图片描述

    • 子 查 询 ( 内 查 询 ) 在 主 查 询 之 间 一 次 执 行 完 成 。 \color{red}{子查询(内查询)在主查询之间一次执行完成。}
    • 子 查 询 的 结 果 被 主 查 询 使 用 ( 外 查 询 ) 。 \color{red}{子查询的结果被主查询使用(外查询)。} 使

    子查询的类型

    在这里插入图片描述

    单行子查询

    • 只返回一条记录
    • 单行操作符
    操作符含义
    =Equal to
    >Greater than
    >=Greater than or equal to
    <Less than
    <=Less than or equal to
    <>Not equal to

    示例1:

    select ename,job,sal
    from emp
    where job=
          (select job
          from emp
          where empno=7566) and sal >
                (select sal
                from emp
                where empno=7782);
    

    在这里插入图片描述
    示例2:

    select ename,job,sal
    from emp
    where sal=
         (select min(sal)
         from emp);
    

    在这里插入图片描述
    示例3:

    select deptno,min(sal)
    from emp
    group by deptno
    having min(sal) >
          (select min(sal)
          from emp
          where deptno=20);
    

    在这里插入图片描述
    示例4:
    查询出比雇员7654的工资高,同时从事和7788的工作一样的员工

    select *
    from emp t1
    where t1.sal>
          (select t.sal 
          from emp t 
          where t.empno=7654) and t1.job=
                (select t2.job
                from emp t2
                where t2.empno=7654);
    

    在这里插入图片描述
    示例5:
    要求查询每个部门的最低工资和最低工资的雇员和部门名称

     select d.dname, a.minsal, e.ename
     from dept d,
          (select deptno, min(sal) minsal 
          from emp
          group by deptno) a,emp e
     where d.deptno=a.deptno and e.sal=a.minsal;
    

    在这里插入图片描述

    非法使用单行子查询示例

    select empno,ename
    from emp
    where sal=
         (select min(sal)
         from emp
         group by deptno);
    

    在这里插入图片描述

    多行子查询

    • 返回了多条记录
    • 多行操作符
    操作符含义
    IN等于列表中的任何一个
    ANY和子查询返回的任意一个值比较
    ALL和子查询返回的所有值比较

    示例:in 在集合中
    查询部门名称是SALES和ACOUNTING的员工

    select * from emp where deptno in
           (select deptno from dept where dname='SALES' or dname='ACCOUNTING');
    

    在这里插入图片描述
    示例:any 和集合中的任意一个值比较
    查询工资比30号部门员工高的员工信息

    select * from emp where sal > any
           (select sal from emp where deptno=30);
    

    在这里插入图片描述
    示例:all 和集合中的所有值比较
    查询工资比30号部门所有员工高的员工信息

    select * from emp where sal > all
           (select sal from emp where deptno=30);
    

    在这里插入图片描述

    子查询需要注意的问题

    • 括号
    • 合理的书写风格
    • 可以在主查询的where、select、having、from后面使用子查询
    • 不可以在group by使用子查询
    • 强调from后面的子查询
    • 主查询和子查询可以不是同一张表;只有子查询返回的结果 主查询可以使用 即可
    • 一般不在子查询中排序;但在top-n分析问题中,必须对子查询排序
    • 一般先执行子查询,再执行主查询;相关子查询列外
    • 单行子查询只能使用单行操作符;多行子查询只能使用多行操作符
    • 子查询中的null

    示例:在select语句后使用子查询
    注意:select语句后的子查询必须是单行子查询
    查询员工号,姓名,薪水,7839的职位

    select empno,ename,sal,
           (select job 
           from emp 
           where empno=7839)
    from emp;
    

    在这里插入图片描述
    示例:在from语句后面使用子查询
    查询员工信息:员工号,姓名,月薪

    select * 
    from (select empno, ename, sal from emp);
    

    在这里插入图片描述
    示例:top-n分析问题
    rownum行号:

    1. rownum永远按照默认的顺序生成
    2. rownum只能使用小于等于,不能使用大于等于

    查询员工表中工资最高的前三名

    select rownum, empno, ename, sal
    from (select * from emp order by sal desc)
    where rownum <= 3;
    

    在这里插入图片描述
    示例:找到员工表中薪水大于本部门平均薪水的员工

    select e.empno, e.ename, e.sal, d.avgsal
    from emp e, (select deptno, avg(sal) avgsal from emp group by deptno) d
    where e. deptno=d.deptno and e.sal > d.avgsal;
    

    在这里插入图片描述
    相关子查询:
    将主查询中的值 作为参数传递给子查询
    使用相关子查询解决上面的示例

    select empno, ename, sal, (select avg(sal) from emp where deptno=e.deptno) avgsal
    from emp e
    where sal > (select avg(sal) from emp where deptno=e.deptno);
    

    在这里插入图片描述

    示例:统计每年入职员工的个数

    select count(*) Total,
           sum(decode(to_char(hiredate, 'yyyy'), '1980', 1, 0)) "1980",
           sum(decode(to_char(hiredate, 'yyyy'), '1981', 1, 0)) "1981",
           sum(decode(to_char(hiredate, 'yyyy'), '1982', 1, 0)) "1982",
           sum(decode(to_char(hiredate, 'yyyy'), '1987', 1, 0)) "1987"
    from emp;
    

    在这里插入图片描述

    子查询中的null值问题

    • 单行子查询中的null值问题
      在这里插入图片描述- 多行子查询中的null值问题
      示例:查询不是老板的员工
      在这里插入图片描述在这里插入图片描述查询错误,集合中有null值不可以使用not in
    展开全文
  • 在mysql中如何进行子查询

    千次阅读 2021-01-19 06:04:40
    在mysql中,子查询是指将一个查询语句嵌套在另一个查询语句中,可以在SELECT、UPDATE和 DELETE语句中配合WHERE子句进行实现,WHERE子句中语法格式为“WHERE (另一个查询语句)”。(推荐教程:mysql视频教程)子查询是 ...

    在mysql中,子查询是指将一个查询语句嵌套在另一个查询语句中,可以在SELECT、UPDATE和 DELETE语句中配合WHERE子句进行实现,WHERE子句中语法格式为“WHERE (另一个查询语句)”。

    5f891345d5bf2368.jpg

    (推荐教程:mysql视频教程)

    子查询是 MySQL 中比较常用的查询方法,通过子查询可以实现多表查询。子查询指将一个查询语句嵌套在另一个查询语句中。子查询可以在 SELECT、UPDATE 和 DELETE 语句中使用,而且可以进行多层嵌套。在实际开发时,子查询经常出现在 WHERE 子句中。

    子查询在 WHERE 中的语法格式如下:WHERE (子查询语句)

    其中,操作符可以是比较运算符和 IN、NOT IN、EXISTS、NOT EXISTS 等关键字。

    1)IN | NOT IN

    当表达式与子查询返回的结果集中的某个值相等时,返回 TRUE,否则返回 FALSE;若使用关键字 NOT,则返回值正好相反。

    2)EXISTS | NOT EXISTS

    用于判断子查询的结果集是否为空,若子查询的结果集不为空,返回 TRUE,否则返回 FALSE;若使用关键字 NOT,则返回的值正好相反。

    例 1

    使用子查询在 tb_students_info 表和 tb_course 表中查询学习 Java 课程的学生姓名,SQL 语句和运行结果如下。mysql> SELECT name FROM tb_students_info

    -> WHERE course_id IN (SELECT id FROM tb_course WHERE course_name = 'Java');

    +-------+

    | name |

    +-------+

    | Dany |

    | Henry |

    +-------+

    2 rows in set (0.01 sec)

    结果显示,学习 Java 课程的只有 Dany 和 Henry。上述查询过程也可以分为以下 2 步执行,实现效果是相同的。

    1)首先单独执行内查询,查询出 tb_course 表中课程为 Java 的 id,SQL 语句和运行结果如下。mysql> SELECT id FROM tb_course

    -> WHERE course_name = 'Java';

    +----+

    | id |

    +----+

    | 1 |

    +----+

    1 row in set (0.00 sec)

    可以看到,符合条件的 id 字段的值为 1。

    2)然后执行外层查询,在 tb_students_info 表中查询 course_id 等于 1 的学生姓名。SQL 语句和运行结果如下。mysql> SELECT name FROM tb_students_info

    -> WHERE course_id IN (1);

    +-------+

    | name |

    +-------+

    | Dany |

    | Henry |

    +-------+

    2 rows in set (0.00 sec)

    习惯上,外层的 SELECT 查询称为父查询,圆括号中嵌入的查询称为子查询(子查询必须放在圆括号内)。MySQL 在处理上例的 SELECT 语句时,执行流程为:先执行子查询,再执行父查询。

    例 2

    与例 1 类似,在 SELECT 语句中使用 NOT IN 关键字,查询没有学习 Java 课程的学生姓名,SQL 语句和运行结果如下。mysql> SELECT name FROM tb_students_info

    -> WHERE course_id NOT IN (SELECT id FROM tb_course WHERE course_name = 'Java');

    +--------+

    | name |

    +--------+

    | Green |

    | Jane |

    | Jim |

    | John |

    | Lily |

    | Susan |

    | Thomas |

    | Tom |

    | LiMing |

    +--------+

    9 rows in set (0.01 sec)

    可以看出,运行结果与例 1 刚好相反,没有学习 Java 课程的是除了 Dany 和 Henry 之外的学生。

    例 3

    使用=运算符,在 tb_course 表和 tb_students_info 表中查询出所有学习 Python 课程的学生姓名,SQL 语句和运行结果如下。mysql> SELECT name FROM tb_students_info

    -> WHERE course_id = (SELECT id FROM tb_course WHERE course_name = 'Python');

    +------+

    | name |

    +------+

    | Jane |

    +------+

    1 row in set (0.00 sec)

    结果显示,学习 Python 课程的学生只有 Jane。

    例 4

    使用<>运算符,在 tb_course 表和 tb_students_info 表中查询出没有学习 Python 课程的学生姓名,SQL 语句和运行结果如下。mysql> SELECT name FROM tb_students_info

    -> WHERE course_id <> (SELECT id FROM tb_course WHERE course_name = 'Python');

    +--------+

    | name |

    +--------+

    | Dany |

    | Green |

    | Henry |

    | Jim |

    | John |

    | Lily |

    | Susan |

    | Thomas |

    | Tom |

    | LiMing |

    +--------+

    10 rows in set (0.00 sec)

    可以看出,运行结果与例 3 刚好相反,没有学习 Python 课程的是除了 Jane 之外的学生。

    例 5

    查询 tb_course 表中是否存在 id=1 的课程,如果存在,就查询出 tb_students_info 表中的记录,SQL 语句和运行结果如下。mysql> SELECT * FROM tb_students_info

    -> WHERE EXISTS(SELECT course_name FROM tb_course WHERE id=1);

    +----+--------+------+------+--------+-----------+

    | id | name | age | sex | height | course_id |

    +----+--------+------+------+--------+-----------+

    | 1 | Dany | 25 | 男 | 160 | 1 |

    | 2 | Green | 23 | 男 | 158 | 2 |

    | 3 | Henry | 23 | 女 | 185 | 1 |

    | 4 | Jane | 22 | 男 | 162 | 3 |

    | 5 | Jim | 24 | 女 | 175 | 2 |

    | 6 | John | 21 | 女 | 172 | 4 |

    | 7 | Lily | 22 | 男 | 165 | 4 |

    | 8 | Susan | 23 | 男 | 170 | 5 |

    | 9 | Thomas | 22 | 女 | 178 | 5 |

    | 10 | Tom | 23 | 女 | 165 | 5 |

    | 11 | LiMing | 22 | 男 | 180 | 7 |

    +----+--------+------+------+--------+-----------+

    11 rows in set (0.01 sec)

    由结果可以看到,tb_course 表中存在 id=1 的记录,因此 EXISTS 表达式返回 TRUE,外层查询语句接收 TRUE 之后对表 tb_students_info 进行查询,返回所有的记录。

    EXISTS 关键字可以和其它查询条件一起使用,条件表达式与 EXISTS 关键字之间用 AND 和 OR 连接。

    例 6

    查询 tb_course 表中是否存在 id=1 的课程,如果存在,就查询出 tb_students_info 表中 age 字段大于 24 的记录,SQL 语句和运行结果如下。mysql> SELECT * FROM tb_students_info

    -> WHERE age>24 AND EXISTS(SELECT course_name FROM tb_course WHERE id=1);

    +----+------+------+------+--------+-----------+

    | id | name | age | sex | height | course_id |

    +----+------+------+------+--------+-----------+

    | 1 | Dany | 25 | 男 | 160 | 1 |

    +----+------+------+------+--------+-----------+

    1 row in set (0.01 sec)

    结果显示,从 tb_students_info 表中查询出了一条记录,这条记录的 age 字段取值为 25。内层查询语句从 tb_course 表中查询到记录,返回 TRUE。外层查询语句开始进行查询。根据查询条件,从 tb_students_info 表中查询 age 大于 24 的记录。

    拓展

    子查询的功能也可以通过表连接完成,但是子查询会使 SQL 语句更容易阅读和编写。

    一般来说,表连接(内连接和外连接等)都可以用子查询替换,但反过来却不一定,有的子查询不能用表连接来替换。子查询比较灵活、方便、形式多样,适合作为查询的筛选条件,而表连接更适合于查看连接表的数据。

    展开全文
  • update子查询

    千次阅读 2019-03-27 19:14:38
    1, 关联子查询和非关联子查询 在非关联子查询中,内部查询只执行一次并返回它的值给外部查询,然后外部查询在它的处理中使用内部查询返回给它的值。而在关联子查询中,对于外部查询返回的每一行数据,内部查询都要...
  • MySQL中的子查询用法

    千次阅读 2019-06-26 18:11:05
    子查询 导入知识 1.select字句的构成 select … from … where … group by having … order by 子查询 1.子查询是什么? 查询里面嵌套查询,也就是select里面还有select select …(select) from …(select) ...
  • 上一篇????:Oracle-----多表查询与分组统计&having子句&分组案例 文章目录1、子查询简介 ...我是近视的脚踏实地,这篇...在整个SQL查询语句过程中,子查询并不是具备特殊的语法,也就是说在整个SQL查询操作...
  • sql语句的子查询

    千次阅读 2021-01-28 10:19:03
    子查询又叫嵌套查询,总结一下子查询的各种操作和处理,以便于记忆和熟练的运用。 概念:什么是子查询子查询就是将一个查询语句嵌套在另一个查询语句中,内层语句的查询结果,可以作为外层查询语句的条件。 ...
  • 子查询和联表查询的区别和优化

    千次阅读 2021-01-20 00:09:47
    子查询1 MySQL从4.1版本开始支持子查询,使用子查询进行SELECT语句嵌套查询,可以一次完成很多逻辑上需要多个步骤才能完成的SQL操作2 子查询虽然很灵活,但是执行效率并不高3 执行子查询时,SQL语句中进行嵌套了...
  • 连接查询和子查询哪个效率高

    万次阅读 多人点赞 2021-03-04 00:44:12
    需要进行多表查询的情况下,用连接查询和子查询哪个效率高? 1、什么是子查询?举个简单的例子,那么子查询有什么优劣呢? 子查询 (内查询) 在主查询之前一次执行完成。 子查询的结果被主查询(外查询)使用 。 可以...
  • SQL子查询和关联子查询

    千次阅读 2020-09-05 13:03:58
    SQL语句的复杂查询语句,包括标量子查询及关联子查询
  • SQL语句(五)子查询

    千次阅读 2021-08-03 10:16:54
    文章目录一、子查询含义二、子查询分类按子查询的位置分按结果集的行列数不同分三、WHERE后面的子查询1. 标量子查询2. 列子查询(多行子查询)3. 行子查询(结果为一行多列或多行多列)四 、SELECT后面的子查询五、...
  • 一文详解SQL关联子查询

    千次阅读 2021-03-30 13:42:20
    简介:本文主要介绍什么是关联子查询以及如何将关联子查询改写为普通语义的sql查询。 本文主要介绍什么是关联子查询以及如何将关联子查询改写为普通语义的sql查询。 在背景介绍中我们将讲讲常见的关联子查询的...
  • postgresql子查询优化(提升子查询)

    千次阅读 2018-08-20 17:31:52
    问题背景 在开发项目过程中,客户要求使用gbase8s数据库(基于informix),简单的分页页面...在数据库实现早期,查询优化器对子查询一般采用嵌套执行的方式,即父查询中的每一行,都要执行一次子查询,这样子查询会执...
  • SQL子查询优化

    千次阅读 2018-07-26 23:26:36
    在此研究下SQL子查询的相关知识 ~ 以下内容主要参考《数据库查询优化器的艺术》一书 一、子查询介绍 概念:当一个查询是另一个查询的子部分时,称之为子查询(查询语句中嵌套有查询语句)。 子查询出现的位置...
  • select后面的子查询

    千次阅读 2020-08-10 11:21:04
    #案例:查询每个部门的员工个数 SELECT d.*, (SELECT COUNT(*) FROM `employees` e WHERE e.`department_id`=d.`department_id`) 个数 FROM `departments` d; #案例2:查询员工号=102的部门名 #(1)...
  • Mybatis 子查询

    千次阅读 2021-04-07 21:26:19
    子查询: 同表中子查询直接在statement中写,和sql格式一样; 不同表间的子查询通过resultMap来实现: <resultMap type = "Book" id = "BookAndReader" autoMapping = "true"> <id colume = "id" property...
  • MySQL where型子查询

    千次阅读 2021-01-18 23:02:09
    where型子查询是内层查询的结果,作为外层sql的比较条件.select goods_id, goods_name from goods where goods_id = (select max(goods_id) from goods);内层查询为select max(goods_id) from goods外层查询为...
  • 子查询一般分为几种

    千次阅读 2021-01-20 01:41:48
    一、mysql子查询基本知识子查询就是在原有的查询语句中,嵌入新的查询,来得到我们想要的结果集。子查询一般分为:where型子查询、from型子查询和exists型子查询。1.where型子查询:将内层查询结果当做外层查询的比较...
  • sql 子查询 嵌套查询In the real world, there are times when we need a particular set of data but we don’t have the exact details for getting the data set. In such cases, we try to get the information ...
  • 九、MySQL数据库之HAVING与子查询

    千次阅读 2020-07-07 22:50:43
    之前我们说这个GROUP BY 的时候,说了一下这个HAVING啊,我差点给忘记了,今天一起和子查询一起都给它说了,省的到时候忘记了再 HAVING 先来说这个HAVING,HAVING和这个WHERE类似,可以说是一对兄弟,但是呢,又不...
  • MySql-子查询

    千次阅读 2021-06-01 09:13:32
    子查询是指出现在其他SQL语句内的SELECT子句。 例如: SELECT * FROM t1 WHERE col1=(SELECT col2 FROM t2); 子查询指嵌套在查询内部,且必须始终出现在圆括号内,子查询可以分为四类: 标量子查询:返回单一值的...
  • 连接查询和子查询

    万次阅读 2018-10-07 16:47:57
    常用的多表连接查询  内连接(INNER JOIN) 外连接 左外连接 (LEFT JOIN) 右外连接 (RIGHT JOIN)   内连接  //内连接是查询有相同记录的  内连接使用比较运算符根据每个表的通用列中的值匹配两个表中的...
  • ORACLE数据库(四)----子查询

    千次阅读 2021-03-15 21:23:12
    文章目录一、子查询作为条件二、子查询作为数据源三、子查询作为常量四、子查询进行增删改五、子查询分类1 语法2 注意 一、子查询作为条件 查询结果作为一个集合,跟在WHERE或HAVING字句中 1.查询SMITH所在部门的...
  • MySQL高级查询与编程笔记 • 【第3章 子查询

    千次阅读 多人点赞 2020-12-13 13:13:13
    3.1 子查询定义和单行子查询 3.1.1 子查询定义 3.1.2 单行子查询应用 3.1.4 实践练习 3.2 多行子查询应用 3.2.1 in 比较符 3.2.3 any|some 关键字子查询 3.2.4 实践练习 3.3 子查询特殊应用 3.3.1 from ...
  • SQL教程——子查询

    万次阅读 2020-11-30 15:30:19
    摘要:本文主要介绍SQL的子查询 目录 目录: 一、where或having后面 1、标量子查询 2、列子查询 3、行子查询 二、select后面 三、from后面 四、exists后面(相关子查询子查询 含义: 出现在其它语句...
  • 子查询 什么是子查询 子查询概念 子查询:sub query   子查询是一种常用计算机语言SELECT-SQL语言中嵌套查询下层的程序模块。当一个查询是另一个查询的条件时,称之为子查询子查询:指在一条select语句中...
  • Python - SQLAlchemy 子查询

    千次阅读 2020-08-26 18:42:56
    Python - SQLAlchemy 子查询 Max.Bai 2020-08 1. 子查询需要先执行subquery 2. 子查询的列需要通过c来访问 比如: sub_query.c.alarm base_sub_query = ( db.query( AlarmRule.alarm, AlarmRule.condition...
  • 关联子查询的执行顺序是什么

    千次阅读 2021-01-19 17:42:57
    sql的编写顺序select .. from .. where .. group by ..having .....关联子查询 :在关联子查询中,对于外部查询返回的每一行数据,内部查询都要执行一次。另外,在关联子查询中是信息流是双向的。外部查询的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 960,616
精华内容 384,246
关键字:

子查询

友情链接: TSR每日波动范围.zip