===============
 子查询表达式
===============

.. container:: sect1
   :name: FUNCTIONS-SUBQUERY

   .. container:: titlepage

      .. container::

         .. container::

            .. rubric:: 子查询表达式
               :name: 子查询表达式
               :class: title

   本节描述 OushuDB 中可用的SQL兼容的子查询表达式。所有本节中成文的表达式都返回布尔值（真/假）结果。

   .. container:: sect2
      :name: FUNCTIONS-SUBQUERY-EXISTS

      .. container:: titlepage

         .. container::

            .. container::

               .. rubric:: ``EXISTS``
                  :name: exists
                  :class: title

      .. code:: synopsis

         EXISTS (subquery)

      ``EXISTS``\ 的参数是一个任意的\ ``SELECT``\ 语句，
      或者说\ *子查询*\ 。系统对子查询进行运算以判断它是否返回行。如果它至少返回一行，那么\ ``EXISTS``\ 的结果就为“真”；
      如果子查询没有返回行，那么\ ``EXISTS``\ 的结果是“假”。

      子查询可以引用来自周围的查询的变量，这些变量在该子查询的任何一次计算中都起常量的作用。

      这个子查询通常只是运行到能判断它是否可以返回至少一行为止，
      而不是等到全部结束。在这里写任何有副作用的子查询都是不明智的（例如调用序列函数）；这些副作用是否发生是很难判断的。

      因为结果只取决于是否会返回行，而不取决于这些行的内容，
      所以这个子查询的输出列表通常是无关紧要的。一个常用的编码习惯是用\ ``EXISTS(SELECT 1 WHERE ...)``\ 的形式写所有的\ ``EXISTS``\ 测试。不过这条规则有例外，例如那些使用\ ``INTERSECT``\ 的子查询。

      下面这个简单的例子类似在\ ``col2``\ 上的一次内联接，但是它为每个
      ``tab1``\ 的行生成最多一个输出，即使存在多个匹配\ ``tab2``\ 的行也如此∶

      .. code:: screen

         SELECT col1
         FROM tab1
         WHERE EXISTS (SELECT 1 FROM tab2 WHERE col2 = tab1.col2);

   .. container:: sect2
      :name: FUNCTIONS-SUBQUERY-IN

      .. container:: titlepage

         .. container::

            .. container::

               .. rubric:: ``IN``
                  :name: in
                  :class: title

      .. code:: synopsis

         expression IN (subquery)

      右手边是一个圆括弧括起来的子查询，
      它必须正好只返回一个列。左手边表达式将被计算并与子查询结果逐行进行比较。
      如果找到任何等于子查询行的情况，那么\ ``IN``\ 的结果就是“真”。
      如果没有找到相等行，那么结果是“假”（包括子查询没有返回任何行的情况）。

      请注意如果左手边表达式得到空值，或者没有相等的右手边值，
      并且至少有一个右手边行得到空值，那么\ ``IN``\ 结构的结果将是空值，而不是假。这个行为是遵照
      SQL 处理空值的一般规则的。

      和\ ``EXISTS``\ 一样，假设子查询将被完成运行完全是不明智的。

      .. code:: synopsis

         row_constructor IN (subquery)

      这种形式的\ ``IN``\ 的左手边是一个行构造器，
      右手边是一个圆括弧子查询，它必须返回和左手边返回的行中表达式所构成的完全一样多的列。
      左手边表达式将被计算并与子查询结果逐行进行比较。如果找到任意相等的子查询行，则\ ``IN``\ 的结果为“真”。如果没有找到相等行，
      那么结果为“假”（包括子查询不返回行的情况）。

      通常，表达式或者子查询行里的空值是按照 SQL
      布尔表达式的一般规则进行组合的。
      如果两个行对应的成员都非空并且相等，那么认为这两行相等；如果任意对应成员为非空且不等，那么这两行不等；
      否则这样的行比较的结果是未知（空值）。如果所有行的结果要么是不等，
      要么是空值，并且至少有一个空值，那么\ ``IN``\ 的结果是空值。

   .. container:: sect2
      :name: FUNCTIONS-SUBQUERY-NOTIN

      .. container:: titlepage

         .. container::

            .. container::

               .. rubric:: ``NOT IN``
                  :name: not-in
                  :class: title

      .. code:: synopsis

         expression NOT IN (subquery)

      右手边是一个用圆括弧包围的子查询，它必须返回正好一个列。左手边表达式将被计算并与子查询结果逐行进行比较。
      如果只找到不相等的子查询行（包括子查询不返回行的情况），那么\ ``NOT IN``\ 的结果是“真”。
      如果找到任何相等行，则结果为“假”。

      请注意如果左手边表达式得到空值，或者没有相等的右手边值，
      并且至少有一个右手边行得到空值，那么\ ``NOT IN``\ 结构的结果将是空值，而不是真。这个行为是遵照
      SQL 处理空值的一般规则的。

      和\ ``EXISTS``\ 一样，假设子查询会完全结束是不明智的。

      .. code:: synopsis

         row_constructor NOT IN (subquery)

      这种形式的\ ``NOT IN``\ 的左手边是一个行构造器，
      右手边是一个圆括弧子查询，它必须返回和左手边返回的行中表达式所构成的完全一样多的列。
      左手边表达式将被计算并与子查询结果逐行进行比较。如果找到不等于子查询行的行，则\ ``NOT IN``\ 的结果为“真”。如果找到相等行，
      那么结果为“假”（包括子查询不返回行的情况）。

      通常，表达式或者子查询行里的空值是按照 SQL
      布尔表达式的一般规则进行组合的。
      如果两个行对应的成员都非空并且相等，那么认为这两行相等；如果任意对应成员为非空且不等，那么这两行不等；
      否则这样的行比较的结果是未知（空值）。如果所有行的结果要么是不等，
      要么是空值，并且至少有一个空值，那么\ ``NOT IN``\ 的结果是空值。

   .. container:: sect2
      :name: FUNCTIONS-SUBQUERY-ANY-SOME

      .. container:: titlepage

         .. container::

            .. container::

               .. rubric:: ``ANY``/``SOME``
                  :name: anysome
                  :class: title

      .. code:: synopsis

         expression operator ANY (subquery)
         expression operator SOME (subquery)

      这种形式的右手边是一个圆括弧括起来的子查询，
      它必须返回正好一个列。左手边表达式将被计算并使用给出的
      *``操作符``*\ 对子查询结果逐行进行比较。如果获得任何真值结果，那么\ ``ANY``\ 的结果就是“真”。
      如果没有找到真值结果，那么结果是“假”（包括子查询没有返回任何行的情况）。

      ``SOME``\ 是\ ``ANY``\ 的同义词。\ ``IN``\ 等价于\ ``= ANY``\ 。

      请注意如果没有任何成功并且至少有一个右手边行为该操作符结果生成空值，
      那么\ ``ANY``\ 结构的结果将是空值，而不是假。 这个行为是遵照 SQL
      处理空值布尔组合的一般规则制定的。

      和\ ``EXISTS``\ 一样，假设子查询将被完全运行是不明智的。

      .. code:: synopsis

         row_constructor operator ANY (subquery)
         row_constructor operator SOME (subquery)

      这种形式的左手边是一个行构造器,右手边是一个圆括弧括起来的子查询，
      它必须返回和左手边列表给出的表达式一样多的列。左手边表达式将被计算并使用给出的\ *``操作符``*\ 对子查询结果逐行进行比较。如果比较为任何子查询行返回真，则\ ``ANY``\ 的结果为“真”。如果比较对每一个子查询行都返回假，则结果为“假”（包括子查询不返回行的情况）。如果比较不对任何行返回真并且至少对一行返回
      NULL，则结果为 NULL。

   .. container:: sect2
      :name: FUNCTIONS-SUBQUERY-ALL

      .. container:: titlepage

         .. container::

            .. container::

               .. rubric:: ``ALL``
                  :name: all
                  :class: title

      .. code:: synopsis

         expression operator ALL (subquery)

      ALL 的这种形式的右手边是一个圆括弧括起来的子查询，
      它必须只返回一列。左手边表达式将被计算并使用给出的
      *``操作符``*\ 对子查询结果逐行进行比较。该操作符必须生成布尔结果。
      如果所有行得到真（包括子查询没有返回任何行的情况），\ ``ALL``\ 的结果就是“真”。如果没有存在任何假值结果，那么结果是“假”。如果比较为任何行都不返回假并且对至少一行返回
      NULL，则结果为 NULL。

      ``NOT IN``\ 等价于\ ``<> ALL``\ 。

      和\ ``EXISTS``\ 一样，假设子查询将被完全运行是不明智的。

      .. code:: synopsis

         row_constructor operator ALL (subquery)

      ``ALL``\ 的这种形式的左手边是一个行构造器,
      右手边是一个圆括弧括起来的子查询，它必须返回和左手边行中表达式一样多的列。
      左手边表达式将被计算并使用给出的
      *``操作符``*\ 对子查询结果逐行进行比较。如果对所有子查询行该比较都返回真，那么\ ``ALL``\ 的结果就是“真”（包括子查询没有返回任何行的情况）。如果对任何子查询行比较返回假，则结果为“假”。如果比较对任何子查询行都不返回假并且对至少一行返回
      NULL，则结果为 NULL。

   .. container:: sect2
      :name: id-1.5.8.27.15

      .. container:: titlepage

         .. container::

            .. container::

               .. rubric:: 单一行比较
                  :name: 单一行比较
                  :class: title

      .. code:: synopsis

         row_constructor operator (subquery)

      左手边是一个行构造器,
      右手边是一个圆括弧括起来的子查询，该查询必须返回和左手边行中表达式数目完全一样的列。
      另外，该子查询不能返回超过一行的数量（如果它返回零行，那么结果就是空值）。
      左手边被计算并逐行与右手边的子查询结果行比较。