精华内容
下载资源
问答
  • 2020-07-10 17:34:52

    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 from the available set of information that we have. To achieve such target we use SQL subquery.

    在现实世界中,有时候我们需要特定的数据集,但是我们没有获取数据集的确切细节。 在这种情况下,我们尝试从现有的可用信息集中获取信息。 为了实现这样的目标,我们使用SQL子查询。

    SQL子查询 (SQL Subquery)

    SQL subquery is a query nested inside another query. Most of the subqueries are used with WHERE clause of a query.

    SQL子查询是嵌套在另一个查询中的查询。 大多数子查询与查询的WHERE子句一起使用。

    SQL子查询规则 (SQL Subquery Rules)

    • A Subquery can be used with different SQL clauses like WHERE clause, HAVING clause and FROM clause.

      子查询可以与不同SQL子句(如WHERE子句,HAVING子句和FROM子句)一起使用。
    • Subqueries can be used with SELECT, UPDATE, INSERT and DELETE statements also.

      子查询也可以与SELECTUPDATEINSERTDELETE语句一起使用。
    • The order of execution starts from subquery first then the main query.

      执行顺序从子查询开始,然后是主查询。
    • The Subquery must be enclosed in parentheses.

      子查询必须用括号括起来。
    • An ORDER BY command cannot be used in a subquery, even though the main query can use an ORDER BY. The GROUP BY command can be used to perform the same function as the ORDER BY in a subquery.

      一个借命令命令不能在子查询中使用,即使主查询就可以使用ORDER BY。 GROUP BY命令可用于执行与子查询中的ORDER BY相同的功能。
    • When a subquery is used along with a comparison operator it should be on the right side of the comparison operator.

      当子查询与比较运算符一起使用时,它应位于比较运算符的右侧。

    SQL子查询语法 (SQL Subquery Syntax)

    SELECT column_name FROM table_name 
    WHERE column_name OPERATOR (SELECT column_name FROM table_name WHERE condition);

    The query inside the parenthesis after the OPERATOR is the subquery and the query outside the parenthesis is the main query.

    OPERATOR之后在圆括号内的查询是子查询,而在圆括号外的查询是主查询。

    SQL子查询示例 (SQL Subquery Example)

    Let us consider the following two tables in order to understand Subquery in a better way.

    让我们考虑以下两个表,以便更好地理解子查询。

    Student

    学生

    Roll NoNameAgeGender
    1Amit12M
    2John13M
    3Diana14F
    4Henry15M
    卷号 名称 年龄 性别
    1个 阿米特 12 中号
    2 约翰 13 中号
    3 戴安娜 14 F
    4 亨利 15 中号

    Class

    ClassSectionRoll No
    6A1
    7A2
    8A3
    9B4
    部分 卷号
    6 一个 1个
    7 一个 2
    8 一个 3
    9 4

    Please find below the MySQL queries to create the tables and insert the data.

    请在下面MySQL查询中查找以创建表并插入数据。

    CREATE TABLE `student` (
      `RollNo` INT NOT NULL,
      `Name` VARCHAR(45) NULL,
      `Age` INT NULL,
      `Gender` VARCHAR(45) NULL,
      PRIMARY KEY (`RollNo`));
      
      
      CREATE TABLE `class` (
      `ClassNo` INT NOT NULL,
      `Section` VARCHAR(45) NULL,
      `RollNo` INT NULL,
      PRIMARY KEY (`ClassNo`));
      
      
      INSERT INTO `student` (`RollNo`, `Name`, `Age`, `Gender`)
    VALUES
    	(1, 'Amit', 12, 'M'),
    	(2, 'John', 13, 'M'),
    	(3, 'Diana', 14, 'F'),
        (4,'Henry', 15,'M');
    	
    	 INSERT INTO `class` (`ClassNo`, `Section`, `RollNo`)
    VALUES
    	(6, 'A', 1),
    	(7, 'A', 2),
    	(8, 'A', 3),
        (9,'B', 4);

    Let us try to look into some examples using SQL subqueries.

    让我们尝试研究一些使用SQL子查询的示例。

    1. SQL subquery for getting all the student’s name with section ‘A’

      SQL子查询,用于获取“ A”部分的所有学生姓名
    2. SELECT Name FROM student 
      WHERE RollNo IN (SELECT RollNo FROM class WHERE section = 'A')
      Name
      Amit
      John
      Diana
      名称
      阿米特
      约翰
      戴安娜
      SQL nested query example

      SQL SubQuery with IN operator

      带IN运算符SQL SubQuery

    3. SQL subquery with class greater than 7

      类大于7SQL子查询
    4. SELECT * FROM student 
      WHERE RollNo IN (SELECT RollNo FROM class WHERE ClassNo>7)
      RollNoNameAgeGender
      3Diana14F
      4Henry15M
      卷号 名称 年龄 性别
      3 戴安娜 14 F
      4 亨利 15 中号
    SQL Subquery with where clause

    SQL subquery with Greater than operator

    具有大于运算符SQL子查询

    翻译自: https://www.journaldev.com/23945/sql-subquery-nested-query-sql

    sql 子查询 嵌套查询

    更多相关内容
  • SQL子查询优化

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

    背景:
    在此研究下SQL子查询的相关知识 ~ 以下内容主要参考《数据库查询优化器的艺术》一书


    一、子查询介绍

    概念:当一个查询是另一个查询的子部分时,称之为子查询(查询语句中嵌套有查询语句)。

    子查询出现的位置有:

    a)目标列位置:子查询如果位于目标列,则只能是标量子查询,否则数据库可能返回类似“错误: 子查询必须只能返回一个字段”的提示。

    注:标量子查询 - SQL允许子查询出现在返回单个值的表达式能够出现的任何地方,只要该子查询只返回包含单个属性的单个元组;这样的子查询称为标量子查询(scalar subquery)。

    错误示范:
    这里写图片描述
    这里写图片描述

    正确写法(标量子查询):
    这里写图片描述

    但是在 HiveImpala 中测试甚至连标量子查询都不支持!:
    这里写图片描述
    这里写图片描述

    b)FROM子句位置: 相关子查询 出现在FROM子句中,数据库可能返回类似“在FROM子句中的子查询无法参考相同查询级别中的关系”的提示,所以相关子查询不能出现在FROM子句中;非相关子查询出现在FROM子句中,可上拉子查询到父层,在多表连接时统一考虑连接代价然后择优。
    注:此处我想了下,好像没有from后跟相关子查询的使用情形,这种错误基本不可能犯的。。

    c)WHERE子句位置:出现在WHERE子句中的子查询,是一个条件表达式的一部分,而表达式可以分解为操作符和操作数;根据参与运算的不同的数据类型,操作符也不尽相同,如INT型有“>、<、=、<>”等操作,这对子查询均有一定的要求(如INT型的等值操作,要求子查询必须是标量子查询)。另外,子查询出现在WHERE子句中的格式,也有用谓词指定的一些操作,如IN、BETWEEN、EXISTS等。

    d)JOIN/ON子句位置: JOIN/ON子句可以拆分为两部分,一是JOIN块类似于FROM子句,二是ON子句块类似于WHERE子句,这两部分都可以出现子查询。子查询的处理方式同FROM子句和WHERE子句。

    e)GROUP BY子句位置: 目标列必须和GROUPBY关联。可将子查询写在GROUPBY位置处,但子查询用在GROUPBY处没有实用意义。

    f)ORDER BY子句位置: 可将子查询写在ORDERBY位置处。但ORDERBY操作是作用在整条SQL语句上的,子查询用在ORDERBY处没有实用意义。

    以下这种情况还是有实用的:

    SELECT * FROM `user` AS u ORDER BY (SELECT DATA FROM `customer` c WHERE c.id = u.user_id )

    二、子查询分类

    从对象间的关系看:

    a)相关子查询

    子查询的执行依赖于外层父查询的一些属性值。子查询因依赖于父查询的参数,当父查询的参数改变时,子查询需要根据新参数值重新执行(查询优化器对相关子查询进行优化有一定意义),如:

    SELECT * FROM t1 WHERE col_1 = ANY (SELECT col_1 FROM t2 WHERE t2.col_2 = t1.col_2);
    # 子查询语句中存在父查询的t1表的col_2列

    注:

    ANY关键词可以理解为“对于子查询返回的列中的任一数值,如果比较结果为true,则返回true”。
    ALL 的意思是“对于子查询返回的列中的所有值,如果比较结果为true,则返回true”

    b)非相关子查询

    子查询的执行,不依赖于外层父查询的任何属性值。这样子查询具有独立性,可独自求解,形成一个子查询计划先于外层的查询求解,如:

    SELECT * FROM t1 WHERE col_1 = ANY

    (SELECT col_1 FROM t2 WHERE t2.col_2 = 10);

    //子查询语句中(t2)不存在父查询(t1)的属性

    从特定谓词看:

    a)[NOT] IN/ALL/ANY/SOME子查询

    语义相近,表示“[取反] 存在/所有/任何/任何”,左面是操作数,右面是子查询,是最常见的子查询类型之一。

    b)[NOT] EXISTS子查询

    半连接语义,表示“[取反] 存在”,没有左操作数,右面是子查询,也是最常见的子查询类型之一。

    c)其他子查询

    除了上述两种外的所有子查询。

    从语句的构成复杂程度看

    a)SPJ子查询

    由选择、连接、投影操作组成的查询。

    b)GROUPBY子查询

    SPJ子查询加上分组、聚集操作组成的查询。

    c)其他子查询

    GROUPBY子查询中加上其他子句如Top-N 、LIMIT/OFFSET、集合、排序等操作。

    后两种子查询有时合称非SPJ子查询。

    从结果的角度看:

    a)标量子查询

    子查询返回的结果集类型是一个简单值。

    b)单行单列子查询

    子查询返回的结果集类型是零条或一条单元组。相似于标量子查询,但可能返回零条元组。

    c)多行单列子查询

    子查询返回的结果集类型是多条元组但只有一个简单列。

    d)表子查询

    子查询返回的结果集类型是一个表(多行多列)。


    三、子查询优化

    a)子查询合并(Subquery Coalescing)

    在某些条件下(语义等价:两个查询块产生同样的结果集),多个子查询能够合并成一个子查询(合并后还是子查询,以后可以通过其他技术消除掉子查询)。这样可以把多次表扫描、多次连接减少为单次表扫描和单次连接,如:

    SELECT * FROM t1 WHERE a1<10 AND (
        EXISTS (SELECT a2 FROM t2 WHERE t2.a2<5 AND t2.b2=1) OR 
        EXISTS (SELECT a2 FROM t2 WHERE t2.a2<5 AND t2.b2=2) 
    );

    可优化为:

    SELECT * FROM t1 WHERE a1<10 AND (
        EXISTS (SELECT a2 FROM t2 WHERE t2.a2<5 AND(t2.b2=1 OR t2.b2=2) 
        # 两个ESISTS子句合并为一个,条件也进行了合并
    );

    b)子查询展开(Subquery Unnesting)

    又称子查询反嵌套,又称为子查询上拉。把一些子查询置于外层的父查询中,作为连接关系与外层父查询并列,其实质是把某些子查询重写为等价的多表连接操作(展开后,子查询不存在了,外部查询变成了多表连接)。带来的好处是,有关的访问路径、连接方法和连接顺序可能被有效使用,使得查询语句的层次尽可能的减少。

    常见的IN/ANY/SOME/ALL/EXISTS依据情况转换为半连接(SEMI JOIN)、普通类型的子查询消除等情况属于此类,如:

    SELECT * FROM t1, (SELECT * FROM t2 WHERE t2.a2 >10) v_t2 
    WHERE t1.a1<10 AND v_t2.a2<20;

    可优化为:

    SELECT * FROM t1, t2 WHERE t1.a1<10 AND t2.a2<20 AND t2.a2 >10; 

    /* 子查询变为了t1、t2表的连接操作,相当于把t2表从子查询中上拉了一层 */

    子查询展开的条件:

    a)如果子查询中出现了聚集、GROUPBY、DISTINCT子句,则子查询只能单独求解,不可以上拉到外层。

    b)如果子查询只是一个简单格式的(SPJ格式)查询语句,则可以上拉子查询到外层,这样往往能提高查询效率。子查询上拉,讨论的就是这种格式,这也是子查询展开技术处理的范围。

    把子查询上拉到上层查询,前提是上拉(展开)后的结果不能带来多余的元组,所以子查询展开需要遵循如下规则:

    a)如果上层查询的结果没有重复(即SELECT子句中包含主码),则可以展开其子查询。并且展开后的查询的SELECT子句前应加上DISTINCT标志。

    b)如果上层查询的SELECT语句中有DISTINCT标志,可以直接进行子查询展开。

    如果内层查询结果没有重复元组,则可以展开。

    子查询展开的具体步骤:

    a)将子查询和外层查询的FROM子句连接为同一个FROM子句,并且修改相应的运行参数。

    b)将子查询的谓词符号进行相应修改(如:“IN”修改为“=”)。

    c)将子查询的WHERE条件作为一个整体与外层查询的WHERE条件合并,并用AND条件连接词连接,从而保证新生成的谓词与原旧谓词的上下文意思相同,且成为一个整体。

    c)聚集子查询消除(Aggregate Subquery Elimination)

    通常,一些系统支持的是标量聚集子查询消除。如:

    SELECT * FROM t1 WHERE t1.a1 > (SELECT avg(t2.a2) FROM t2);
    展开全文
  • 昨天去客户方让客户小姐姐给我查询一段sql的时候,竟然发现sql子查询还可以这样写: sql子查询不仅仅可以出现在from 后面作为表结构,譬如: select t1.company_id,t1.company_name,t1.department_id,t2....

    昨天去客户方让客户小姐姐给我查询一段sql的时候,竟然发现sql子查询还可以这样写:

    1. sql子查询不仅仅可以出现在from 后面作为表结构,譬如:

    在这里插入图片描述

    select t1.company_id,t1.company_name,t1.department_id,t2.department_name
    from company t1,
    (select * from department where department_name like '%T%')t2 
    --子查询作为表放在from 后面
    where t1.department_id=t2.department_id;
    

    在这里插入图片描述

    1. sql子查询还可以作为条件放在where后面,譬如:
    select t1.company_id,t1.company_name,t1.department_id,t2.department_name
    from company t1,department t2
    where t1.department_id=(
      select distinct department_id 
      from department 
      where 
      department_name like '%IT%');
    

    在这里插入图片描述

    1. sql子查询还可以出现在select后面作为字段,譬如:
    select t1.company_id,t1.company_name,t1.department_id,
    (select t2.department_name 
    from department t2 
    where t1.department_id=t2.department_id
    )
    from company t1;
    --sql子查询放入select后面做字段使用
    

    这里有个潜在问题,就是用作子查询的语句,查询结果只能是1:1 or n:1,不然就会出现主查询返回一条,但是子查询返回多行:

    ORA-01427: single-row subquery returns more than one row
    

    在这里插入图片描述

    展开全文
  • sql子查询

    万次阅读 2016-10-14 11:09:22
     SQL有着非常强大且灵活的查询方式,而多表连接操作往往也可以用子查询进行替代,本篇文章将会讲述子查询的方方面面。 简介  子查询本质上是嵌套进其他SELECT,UPDATE,INSERT,DELETE语句的一个被限制的SELECT语句,...

    工作中要用到子查询,在网上看到一篇好文章,无耻的转过来,以便后用。

    引言

          SQL有着非常强大且灵活的查询方式,而多表连接操作往往也可以用子查询进行替代,本篇文章将会讲述子查询的方方面面。

    简介

          子查询本质上是嵌套进其他SELECT,UPDATE,INSERT,DELETE语句的一个被限制的SELECT语句,在子查询中,只有下面几个子句可以使用

    1. SELECT子句(必须)
    2. FROM子句(必选)
    3. WHERE子句(可选)
    4. GROUP BY(可选)
    5. HAVING(可选)
    6. ORDER BY(只有在TOP关键字被使用时才可用)

        子查询也可以嵌套在其他子查询中,这个嵌套最多可达32层。子查询也叫内部查询(Inner query)或者内部选择(Inner Select),而包含子查询的查询语句也叫做外部查询(Outter)或者外部选择(Outer Select),子查询的概念可以简单用下图阐述:

    1

       

         上图是作为数据源使用的一个子查询.

         通常来讲,子查询按照子查询所返回数据的类型,可以分为三种,分别为:

    1. 返回一张数据表(Table)
    2. 返回一列值(Column)
    3. 返回单个值(Scalar)

         下面,我们按照这三种方式来阐述子查询

     

    子查询作为数据源使用

         当子查询在外部查询的FROM子句之后使用时,子查询被当作一个数据源使用,即使这时子查询只返回一个单一值(Scalar)或是一列值(Column),在这里依然可以看作一个特殊的数据源,即一个二维数据表(Table).作为数据源使用的子查询很像一个View(视图),只是这个子查询只是临时存在,并不包含在数据库中。

         比如这个语句:

    SELECT     P.ProductID, P.Name, P.ProductNumber, M.Name AS ProductModelName
    FROM         Production.Product AS P INNER JOIN
    (SELECT     Name, ProductModelID
     FROM          Production.ProductModel) AS M 
    ON P.ProductModelID = M.ProductModelID

        上述子查询语句将ProductModel表中的子集M,作为数据源(表)和Product表进行内连接。结果如下:

       2

        作为数据源使用也是子查询最简单的应用。当然,当子查询作为数据源使用时,也分为相关子查询无关子查询,这会在文章后面介绍到.

     

    子查询作为选择条件使用

     

        作为选择条件的子查询也是子查询相对最复杂的应用.

        作为选择条件的子查询是那些只返回一列(Column)的子查询,如果作为选择条件使用,即使只返回单个值,也可以看作是只有一行一列.比如:

        在AdventureWorks中:

        我想取得总共请病假天数大于68小时的员工:

    SELECT [FirstName]
          ,[MiddleName]
          ,[LastName]
      FROM [AdventureWorks].[Person].[Contact]
      WHERE ContactID IN 
    
      (SELECT EmployeeID
      FROM [AdventureWorks].[HumanResources].[Employee]
      WHERE SickLeaveHours>68)

       结果如下:

       3

     

       上面的查询中,在IN关键字后面的子查询返回一列值作为外部查询选择条件使用.

       同样的,与IN关键字的逻辑取反的NOT IN关键字,这里就不再阐述了

       但是要强调的是,不要用IN和NOT IN关键字,这会引起很多潜在的问题,这篇文章对这个问题有着很好的阐述:http://wiki.lessthandot.com/index.php/Subquery_typo_with_using_in。这篇文章的观点是永远不要再用IN和NOT IN关键字,我的观点是存在即合理,我认为只有在IN里面是固定值的时候才可以用IN和NOT IN,比如:

    SELECT [FirstName]
          ,[MiddleName]
          ,[LastName]
      FROM [AdventureWorks].[Person].[Contact]
      WHERE ContactID  IN (25,33)

       只有在上面这种情况下,使用IN和NOT IN关键字才是安全的,其他情况下,最好使用EXISTS,NOT EXISTS,JOIN关键字来进行替代. 除了IN之外,用于选择条件的关键字还有ANYALL,这两个关键字和其字面意思一样. 和"<",">",”="连接使用,比如上面用IN的那个子查询:

       我想取得总共请病假天数大于68小时的员工

       用ANY关键字进行等效的查询为:

    SELECT [FirstName]
          ,[MiddleName]
          ,[LastName]
      FROM [AdventureWorks].[Person].[Contact]
      WHERE ContactID =ANY
    
      (SELECT EmployeeID
      FROM [AdventureWorks].[HumanResources].[Employee]
      WHERE SickLeaveHours>68)

       在作为ANY和ALL关键字在子查询中使用时,所实现的效果如下

    =ANY 和IN等价
    <>ALL 和NOT IN等价
    >ANY 大于最小的(>MIN)
    <ANY 小于最大的(<MAX)
    >ALL 大于最大的(>MAX)
    <ALL 小于最小的(<MIN)
    =ALL 下面说

       =ALL关键字很少使用,这个的效果在子查询中为如果只有一个返回值,则和“=”相等,而如果有多个返回值,结果为空

       这里要注意,SQL是一种很灵活的语言,就像子查询所实现的效果可以使用JOIN来实现一样(效果一样,实现思路不同),ANY和ALL所实现的效果也完全可以使用其他方式来替代,按照上面表格所示,>ANY和>MIN完全等价,比如下面两个查询语句完全等价:

    SELECT *
    FROM AdventureWorks.HumanResources.Employee
    WHERE SickLeaveHours>ANY
    
    (SELECT SickLeaveHours FROM AdventureWorks.HumanResources.Employee WHERE SickLeaveHours>68)
    
    
    SELECT *
    FROM AdventureWorks.HumanResources.Employee
    WHERE SickLeaveHours>
    
    (SELECT MIN(SickLeaveHours) FROM AdventureWorks.HumanResources.Employee WHERE SickLeaveHours>68)

     

     

    相关子查询和EXISTS关键字

       前面所说的查询都是无关子查询(Uncorrelated subquery),子查询中还有一类很重要的查询是相关子查询(Correlated subquery),也叫重复子查询比如,还是上面那个查询,用相关子查询来写:

       我想取得总共请病假天数大于68天的员工:

    SELECT [FirstName]
          ,[MiddleName]
          ,[LastName]
      FROM [AdventureWorks].[Person].[Contact] c
      WHERE EXISTS
    
      (SELECT *
      FROM [AdventureWorks].[HumanResources].[Employee] e
      WHERE c.ContactID=e.ContactID AND e.SickLeaveHours>68)

       结果和使用IN关键字的查询结果相同:

       3

       如何区别相关子查询无关子查询呢?最简单的办法就是直接看子查询本身能否执行,比如上面的例子中的子查询

    (SELECT *
      FROM [AdventureWorks].[HumanResources].[Employee] e
      WHERE c.ContactID=e.ContactID AND e.SickLeaveHours>68)

       这一句本身执行本身会报错.因为这句引用到了外部查询的表

       对于无关子查询来说,整个查询的过程为子查询只执行一次,然后交给外部查询,比如:

      

    SELECT *
    FROM AdventureWorks.HumanResources.Employee
    WHERE SickLeaveHours>ANY
    
    SQLRESULT

       上面的无关子查询,整个查询过程可以看作是子查询首先返回SQLResult(SQL结果集),然后交给外部查询使用,整个过程子查询只执行一次

        而相反,作为相关子查询,子查询的执行的次数依赖于外部查询,外部查询每执行一行,子查询执行一次,比如:

        还是上面的例子:我想取得总共请病假天数大于68天的员工

    SELECT [FirstName]
          ,[MiddleName]
          ,[LastName]
      FROM [AdventureWorks].[Person].[Contact] c
      WHERE EXISTS
    
      (SELECT *
      FROM [AdventureWorks].[HumanResources].[Employee] e
      WHERE c.ContactID=e.ContactID AND e.SickLeaveHours>68)
    
    ----
    step 1:
    SELECT [FirstName]
          ,[MiddleName]
          ,[LastName]
      FROM [AdventureWorks].[Person].[Contact] c
      WHERE EXISTS
    
      (SELECT *
      FROM [AdventureWorks].[HumanResources].[Employee] e
      WHERE 1=e.ContactID AND e.SickLeaveHours>68)
    ----
    step 2:
    SELECT [FirstName]
          ,[MiddleName]
          ,[LastName]
      FROM [AdventureWorks].[Person].[Contact] c
      WHERE EXISTS
    
      (SELECT *
      FROM [AdventureWorks].[HumanResources].[Employee] e
      WHERE 2=e.ContactID AND e.SickLeaveHours>68)
    ----
    step n:
    SELECT [FirstName]
          ,[MiddleName]
          ,[LastName]
      FROM [AdventureWorks].[Person].[Contact] c
      WHERE EXISTS
    
      (SELECT *
      FROM [AdventureWorks].[HumanResources].[Employee] e
      WHERE n=e.ContactID AND e.SickLeaveHours>68)
     

     

      如上面代码所示。上面的相关子查询实际上会执行N次(N取决与外部查询的行数),外部查询每执行一行,都会将对应行所用的参数传到子查询中,如果子查询有对应值,则返回TRUE(既当前行被选中并在结果中显示),如果没有,则返回FALSE。然后重复执行下一行。

     

    子查询作为计算列使用

        当子查询作为计算列使用时,只返回单个值(Scalar) 。用在SELECT语句之后,作为计算列使用。同样分为相关子查询无关子查询

        相关子查询的例子比如:我想取得每件产品的名称和总共的销量

    SELECT [Name],
          (SELECT COUNT(*) FROM AdventureWorks.Sales.SalesOrderDetail S
          WHERE S.ProductID=P.ProductID) AS SalesAmount
    FROM [AdventureWorks].[Production].[Product] P
      

       部分结果如下:

       5

       当子查询作为计算列使用时,会针对外部查询的每一行,返回唯一的值。

       同样的,SQL子查询都可以使用其他语句达到同样的效果,上面的语句和如下语句达到同样的效果:

    SELECT P.Name,COUNT(S.ProductID)
    FROM [AdventureWorks].[Production].[Product] P 
    LEFT JOIN  AdventureWorks.Sales.SalesOrderDetail S
    ON S.ProductID=P.ProductID
    GROUP BY P.Name
      

       子查询作为计算列且作为无关子查询时使用,只会一次性返回但一值,这里就不再阐述了。

     

    小结

         本篇文章通过子查询的三种不同用途来阐述子查询。同时,所有的子查询还可以分为相关子查询和无关子查询,而子查询所实现的功能都可以使用连接或者其他方式实现。但一个好的作家应该是掌握丰富的词汇,而不是仅仅能表达出自己的意思。学会多种SQL查询方式是学习SQL查询必经之路。

    展开全文
  • SQL子查询中SOME、ANY、ALL关键字

    千次阅读 2019-09-20 22:41:12
    SQL中带SOME、ANY、ALL的子查询 准备两个表: –T1(2,3) –T2(1,2,3,4) 测试 “>ALL” : 父查询中的结果集大于子查询中每一个值(大于子查询结果集中的最大值),则为真; select * from T2 where n > ALL...
  • SQL子查询和关联子查询

    千次阅读 2020-09-05 13:03:58
    SQL语句的复杂查询语句,包括标量子查询及关联子查询
  • sql子查询两个表的数据相减

    千次阅读 2021-01-12 11:49:03
    现有表atable和表btable,数据如下:table atableid anumber1 5002 3003 400table btableid bnumber1 5012 3013 401总数据相减:sql:select (select sum(a.number) from atable a) - ...
  • SQL 子查询

    万次阅读 2018-04-21 14:52:19
     SQL还允许创建子查询(subquery),即嵌套在其他查询中的查询。为什么要这样做呢?理解这个概念的最好方法是考察几个例子。利用子查询进行过滤 订单存储在两个表中。每个订单包含订单编号、客户ID、订单日期,在...
  • sql 子查询及基本语句 挺全的收录

    万次阅读 2018-06-06 00:30:35
    引自https://blog.csdn.net/jia_gugang/article/details/80282873一、SQL子查询语句 1、单行子查询 select ename,deptno,sal from emp where deptno=(select deptno from dept where loc='NEW YORK');...
  • sql子查询左链接

    千次阅读 2017-04-28 15:23:24
    1:子查询: (表中字段一一对应 一张表和另外一张表的一个字段唯一确定一行数据)select (select (select wname from wcode where wcode = users_weixin.wcode) from users_weixin where wxicode = users_rec
  • SQL 子查询 EXISTS 和 NOT EXISTS

    万次阅读 多人点赞 2016-11-08 23:00:19
    MySQL EXISTS 和 NOT EXISTS 子查询语法如下: SELECT … FROM table WHERE EXISTS (subquery) 该语法可以理解为:将主查询的数据,放到子查询中做条件验证,根据验证结果(TRUE 或 FALSE)来决定主查询的数据结果...
  • SQL 子查询 NOT EXISTS 的一点理解

    千次阅读 2020-11-21 02:31:03
    SQL 子查询 NOT EXISTS 的一点理解   首先,了解一下NOT EXISTS在子查询中的用法 SELECT … --1号SELECT FROM table WHERE NOT EXISTS ( SELECT … --2号SELECT FROM table WHERE … )   要使1号...
  • sql语句的子查询

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

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

    千次阅读 2018-10-21 17:52:35
    子查询 子查询是嵌套在其他查询中的查询。子查询总是从内向外处理。 注意: 1、在使用子查询时尽量把子查询分解为多行并且适当进行缩进,能极大的简化子查询的使用。 2、不能嵌套太多的子查询,这样会降低性能。...
  • SQL——子查询

    万次阅读 多人点赞 2020-08-12 08:05:23
    子查询 一般而言在一个查询中,可以嵌套另一个查询,即在一个SELECT查询内在嵌入另一个SELECT查询 ,外层的SELECT语句较外部查询,内层的SELECT语句叫子查询子查询可以嵌套多层,但每层需要用“()”括起来,...
  • 子查询sql怎么写

    千次阅读 2020-12-17 14:42:45
    一、子查询简介: 子查询就是嵌套在主查询中的查询。...二、子查询sql示例: 个人认为这个sql很实用,都可以套着用。 select * from user where id in (select s.userid from score s where english = 90)
  • SQL子查询、多表查询、联合查询

    千次阅读 2018-07-29 14:50:25
    1、select * from ta1 where id in ...属于“子查询”。 2、select ta1.*, ta2.* from tab1, tab2 where ta1.[字段]=ta2.[字段] 属于“多表查询”。 3、如:(select * from ta1 where ...) union (select * from ...
  • 且该select语句嵌套在另一个SQL语句(例如select语句、insert语句、update语句或者delete语句)中,那么该select语句成为“子查询”(也叫内层查询),包含子查询SQL语句称为“主查询”(也叫外层查询)。...
  • 第八关:子查询及联合查询
  • sql子查询超级慢-子查询酿的祸

    千次阅读 2019-04-17 10:45:10
    今天碰到一个问题,就是子查询导致查询效率特别低,到了31秒了。特此先记录一下,后期修改。 前提条件:sz_jsxxb这个表是教师表,大约有5万多条数据 select sys_guid(), (select count(zgh)as nanrs from...
  • SQL查询,子查询作为结果字段

    万次阅读 2019-08-23 10:30:16
    SQL查询,子查询作为结果字段, SELECT DISTINCT sp.comcode, sp.projectname, sp.projecttime, sp.busnature, sp.bustype, sl.concode, sl.conname, sl.contype, sl.conpartya, sl.contotal, sl....
  • 执行过程: 从主查询中取出一个元组(表中的行),将元组相关的列的值传递给子查询 子查询将列的值作为条件得到结果 主查询根据子查询得到的结果或者结果集得到满足条件的行,select控制显示 然后主查询取出下一个...
  • SQL子查询—sum()及减法

    万次阅读 2018-05-13 15:28:09
    需求:查询 C 的结果,其中 C = A - B;A的结果需要连表查询;B的结果也需要连表查询;实现:过程一:select sum(A) from 表a aleft join 表b bon a.pid = b.idwhere b.id = 1;过程二:select sum(B) from 表c cleft ...
  • SQL子查询什么时候用

    千次阅读 2014-01-22 18:39:27
    SQL子查询什么时候用
  • sql 查询插入SQL INSERT Query also referred as SQL INSERT INTO is the command used for inserting data into database. SQL INSERT statement allows insertion of data into one table at a time. SQL INSERT...
  • SQL子查询和 LEFT JOIN 关键字

    千次阅读 2019-05-20 17:36:15
    SQL子查询 语法: sno in (SELECT sno FROM p_test WHERE category =“800米” ) WHERE category=“立定跳远” and sno in (SELECT sno FROM p_test WHERE category =“800米” ) 上述语句的意思就是2个条件,类型是...
  • SQL相关子查询与非相关子查询

    万次阅读 多人点赞 2018-07-05 10:31:04
    SQL子查询可以分为相关子查询和非相关子查询两类。 假设Books表如下: 类编号 图书名 出版社 价格 2 c#高级应用 圣通出版 23.00 2 Jsp开发应用 机械出版社...
  • SQL中的子查询的使用

    万次阅读 多人点赞 2018-06-11 13:05:46
    这篇文章讲述了SQL中的子函数,如有错误或者不妥之处,还请各位大佬批评指正。 什么是子查询? 把一个查询的结果在另一个查询中使用就叫做子查询 ...返回的结果集为单个的子查询,叫做单行子查询。单行比较...
  • SQL --子查询与临时表

    万次阅读 2019-04-18 09:22:00
    子查询 --使用子查询提升count distinct的效率 数据库:38_6543 db_hyrhk --1.count distinct很有用,但太慢 ----Count distinct是SQL分析时的祸根所以拿它来做个例子 ----首先,让我们以我们一直使用的一个简单...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 397,555
精华内容 159,022
关键字:

sql子查询