金仓数据库 KingbaseES SQL 语言参考手册 (7. 条件表达式）

7. 条件表达式

条件表达式 指定一个或多个表达式和逻辑（布尔）运算符的组合，并返回TRUE、FALSE的值或UNKNOWN。

本章包含以下部分：

• SQL条件简介

• 比较条件

• 浮点条件

• 逻辑条件

• 模式匹配条件

• 空条件

• SQL/JSON条件

• 复合条件

• BETWEEN条件

• EXISTS条件

• IN条件

7.1. SQL条件简介

条件可以有多种形式，如以下语法所示。

条件:

以下部分描述了各种形式的条件。condition无论何时出现在 SQL 语句中， 您都必须使用适当的条件语法。

您可以在这些语句的WHERE子句中使用条件：

• DELETE

• SELECT

• UPDATE

您可以在SELECT语句的以下任何子句中使用条件：

• WHERE

• START WITH

• CONNECT BY

• HAVING

条件可以说是逻辑数据类型，尽管 KingBase 数据库不正式支持这种数据类型。

以下简单条件总是计算为TRUE：

1 = 1

以下更复杂的条件将salary值与commission_pct值相加（用0代替null）并确定总和是否大于数字常量25000：

NVL(salary, 0) + NVL(salary + (salary*commission_pct, 0) > 25000)

逻辑条件可以将多个条件组合成一个条件。例如，您可以使用AND条件来组合两个条件：

(1 = 1) AND (5 < 7)

以下是一些有效条件：

name = 'SMITH'

employees.department_id = departments.department_id

hire_date > '01-JAN-08'

job_id IN ('SA_MAN', 'SA_REP')

salary BETWEEN 5000 AND 10000 之间

Commission_pct IS NULL AND salary = 2100

• 条件优先级

优先级是 KingBase 数据库在同一表达式中计算不同条件的顺序。在计算包含多个条件的表达式时，KingBase 在计算优先级较低的条件之前先计算优先级较高的条件。KingBase 在表达式中从左到右以相同的优先级计算条件，但以下情况除外：

• 对于使用AND连接的多个条件，不能保证从左到右进行计算

• 对于使用OR连接的多个条件，不能保证从左到右进行计算

以下列出了SQL条件从高到低的优先级。同一行中列出的条件具有相同的优先级。如表所示，KingBase 会在条件之前运算符运算。

条件类型	目的
=, !=, <, >, <=, >=,	比较
IS [NOT] NULL,	比较
LIKE, [NOT] BETWEEN	比较
[NOT] IN, EXISTS, IS OF type	比较
NOT	逻辑否定
AND	连词
OR	或者

7.2. 比较条件

比较条件将一个表达式与另一个表达式进行比较。这种比较的结果可以是TRUE、FALSE或UNKNOWN。

比较条件不支持大对象 (LOB)。但是，您可以使用 PL/SQL 程序来比较CLOB数据。

在比较数字表达式时，KingBase会使用数字优先级来确定该条件是否会比较数字、BINARY_FLOAT或BINARY_DOUBLE值。有关数字优先级的信息，请参考数字优先级。

在比较字符表达式时，KingBase会使用数据类型比较规则中描述的规则。这些规则定义了表达式的字符集如何在比较之前对齐、使用二进制或语言比较（排序）、使用空白填充的比较语义，以及对排序键施加的限制所产生的限制。

如果两个非标量类型的对象具有相同的命名类型，并且它们的元素之间存在一对一的对应关系，则它们具有可比性。此外，用户定义对象类型的嵌套表，即使它们的元素具有可比性，也必须在它们上定义MAP方法，以便在相等条件或IN条件下使用。

以下列出了比较条件

• 条件类型：=，作用：平等检验。

例子：SELECT * FROM employees WHERE salary = 2500 ORDER BY employee_id;

• 条件类型：!= ^= <>，作用：不等式检验。

例子：SELECT * FROM employees WHERE salary！= 2500 ORDER BY employee_id;

• 条件类型：> < ，作用：大于和小于比较。

例子：SELECT * FROM employees WHERE salary > 2500 ORDER BY employee_id;

SELECT * FROM employees WHERE salary < 2500 ORDER BY employee_id;

• 条件类型：>= <=， 作用：大于或等于和小于或等于比较。

例子：SELECT * FROM employees WHERE salary >= 2500 ORDER BY employee_id;

SELECT * FROM employees WHERE salary <= 2500 ORDER BY employee_id;

• op ANY， op SOME ，作用："op" 必须是 =、!=、>、<、<= 或 >= 之一。op ANY使用条件将左侧的值与列表中的每个值或查询返回的每个值进行比较，以右侧指定的为准op。如果这些比较中的任何一个返回 TRUE，则op ANY返回TRUE。如果所有这些比较都返回FALSE，或者右侧的子查询没有返回任何行，则op ANY返回FALSE。否则，返回值为UNKNOWN。op ANY和op SOME是同义词。

例子：SELECT * FROM employees WHERE salary = ANY （SELECT salary FROM employees WHERE Department_id = 30) ORDER BY employee_id;

• op ALL ， 作用说明："op" 必须是 =、!=、>、<、<= 或 >= 之一。op ALL使用条件将左侧的值与列表中的每个值或子查询返回的每个值进行比较，以右侧指定的为准op。如果这些比较中的任何一个返回FALSE，则 op ANY返回FALSE。如果所有这些比较都返回TRUE，或者右侧的子查询没有返回任何行，则op ALL返回TRUE。否则，返回值为UNKNOWN。

示例：SELECT * FROM employees WHERE salary >= ALL (1400, 3000) ORDER BY employee_id;

• 简单比较条件

简单比较条件指定与表达式或子查询结果的比较。

简单比较条件:

表达式列表:

如果使用此条件的下端形式和运算符左侧的单个表达式，则可以使用expression_list的上端或下端形式。如果使用此条件的低形式，运算符左侧有多个表达式，则必须使用expression_list的低形式。在任何一种情况下，expression_list中的表达式都必须在数字和数据类型上与运算符左侧的表达式相匹配。如果指定了子查询，则子查询返回的值必须在数字和数据类型上与运算符左侧的表达式相匹配。

• 组比较条件

组比较条件指定与列表或子查询中的任何或所有成员进行比较。

组比较条件:

表达式列表:

如果使用此条件的上部形式（在运算符的左侧有单个表达式），则必须使用expression_list的上部形式。如果使用此条件的较低形式（在运算符的左侧有多个表达式），则必须使用expression_list的较低形式，并且每个expression_list中的表达式必须在数字和数据类型上与运算符左侧的表达式相匹配。如果指定了子查询，则子查询返回的值必须在数字和数据类型上匹配

7.3. 浮点条件

浮点条件可让您确定表达式是无限的还是运算的未定义结果（不是数字或NaN）。

浮点条件:

在这两种形式的浮点条件中，expr必须解析为数值数据类型或任何可以隐式转换为数值数据类型的数据类型。

浮点条件说明：

• 条件类型：IS [NOT] NAN , 说明：如果expr是特殊值NAN并且NOT未指定，则返回TRUE。如果expr不是指定的NOT时的特殊值NAN，则返回TRUE。

示例：SELECT COUNT(*) FROM employees WHERE commission_pct IS NOT NAN;

• 条件类型：IS [NOT] INFINITE , 说明：当NOT未指定时，如果expr是特殊值+INF或-INF，则返回TRUE。当NOT指定时，如果expr不是+INF也不是-INF，则返回TRUE。

示例：SELECT last_name FROM employees WHERE salary IS NOT INFINITE;

7.4. 逻辑条件

逻辑条件将两个组件条件的结果组合起来，以生成基于它们的单个结果，或反转单个条件的结果。以下列出了逻辑条件。

• 条件类型:NOT , 说明：如果以下条件为TRUE，则返回FALSE。如果是FALSE则返回TRUE。如果是UNKNOWN，那么它仍然存在UNKNOWN。

例子：SELECT * FROM employees WHERE NOT（job_id is NULL） ORDER BY employee_id;

SELECT * from employees WHERE NOT （salary BETWEEN 1000 AND 2000 ） ORDER BY employee_id;

• 条件类型:AND , 说明：如果两个组件条件都是TRUE则返回TRUE。如果其中一个是 FALSE则返回FALSE。否则返回UNKNOWN。

例子：SELECT * FROM employees WHERE job_id = 'PU_CLERK' AND department_id = 30 ORDER BY employee_id;

• 条件类型:OR , 说明：如果任一组件条件为TRUE则返回TRUE。如果两者都是FALSE则返回FALSE。否则返回UNKNOWN。

例子：SELECT * FROM employees WHERE job_id = 'PU_CLERK' OR department_id = 10 ORDER BY employee_id;

下表显示了将NOT条件应用于表达式的结果。

表 NOT真值表

--	真	假	未知
NOT	FALSE	RUE	NKNOWN

下表显示了将AND条件组合到两个表达式的结果。

表 AND 真值表

AND	真	假	未知
TRUE	TRUE	FALSE	UNKNOWN
FALSE	FALSE	FALSE	FALSE
UNKNOWN	UNKNOWN	FALSE	UNKNOWN

例如，在WHERE以下SELECT语句的子句中，AND逻辑条件用于确保仅返回 2004年之前雇佣且工资超过2500的人员：

SELECT * FROM employees WHERE hire_fate < TO_DATE('01-JAN-2004', 'DD-MON-YYYY') AND salary > 2500 ORDER BY employee_id;

下表显示了应用于OR两个表达式的结果。

表 OR 真值表

OR	TRUE	FALSE	UNKNOWN
TRUE	TRUE	TRUE	TRUE
FALSE	TRUE	FALSE	UNKNOWN
UNKNOWN	TRUE	UNKNOWN	UNKNOWN

例如，以下查询返回佣金率为40%或工资大于20,000的员工：

SELECT employes_id from employees WHERE commission_pct = .4 OR salary > 20000 ORDER BY employee_id;

7.5. 模式匹配条件

模式匹配表达式比较字符函数。

• LIKE Condition

  LIKE指定了一个模式匹配的计算。虽然相等运算符 (=) 将一个字符值与另一个字符值完全匹配，但LIKE条件是通过在第一个值中搜索与指定的第二个值匹配的模式，将一个字符的一部分与另一个字符值匹配。LIKE使用输入字符集定义的字符计算字符串。

  like_condition:

  char1 NOT LIKE char2 ESCAPE esc_char

  在这种语法中：

  • char1是一个字符表达式，例如一个字符列，称为搜索值。

  • char2是一个字符表达式，通常是文字，称为模式。

  • esc_char是一个字符表达式，通常是文字，称为转义字符。

  如果未指定esc_char，则没有默认转义字符。如果char1 、char2 或 esc_char中的任何一个为空，则结果未知。否则，转义字符（如果指定）必须是长度为 1 的字符串。

  所有字符表达式（char1、、char2和esc_char）都可以是任何数据类型CHAR、VARCHAR2或NCHARNVARCHAR2。如果它们不同，则 KingBase 将它们全部转换为. char1的数据类型

  模式可以包含特殊的模式匹配字符：

  • 模式中的下划线 (_) 与值中的一个字符（而不是多字节字符集中的一个字节）完全匹配。

  • 模式中的百分号 (%) 可以匹配值中的零个或多个字符（与多字节字符集中的字节相反）。模式“%”不能匹配空值。可以使用标识转义字符的转义子句在模式中包含实际字符%或_。如果转义字符在模式中的字符%或_之前，则Kingbase会直接解释这个字符，而不是作为一个特殊的模式匹配字符。你也可以通过重复它来搜索转义字符本身。例如，如果@是转义字符，则可以使用@@来搜索@。

  只有 与ASCII 匹配的下划线 (_) 和百分号 (%) 字符被识别为模式匹配字符。它们出现在East Aslan character和 Unicode 中的全角变体被视为普通字符。

  以下描述了这些LIKE条件。

  • 条件类型：x [NOT] LIKE y[ESCAPE'z']， 描述：如果x[NOT] 匹配模式y。在y内，该字符%匹配任何零个或多个字符的字符串，但 null 除外。该字符_匹配任何单个字符。ESCAPE除百分号 (%) 和下划线 (_) 外，可以跟随任何字符。如果前面有转义字符，则通配符被视为文字。

  例子：SELECT last_name FROM employees WHERE last_name LIKE '%A_B%' ESCAPE '' ORDER BY last_name；

  为了处理这些LIKE条件，KingBase 将模式划分为子模式，每个子模式由一个或两个字符组成。两个字符的子模式以转义字符开头，另一个字符是 %、_ 或转义字符。

  设 P1 , P2 , ..., Pn是这些子模式。如果有办法将搜索值划分为子字符串 S1、 S2、 ...、 Sn ，则类似条件为真，这样对于1 和n之间的所有i：

  • 如果 Pi是 ，则 Si是单个字符。

  • 如果 Pi是 %，那么 Si是任何字符串。

  • 如果 Pi是以转义字符开头的两个字符，则 Si是Pi的第二个字符。

  • 否则，Pi = Si。

  使用LIKE条件，您可以将值与模式而不是常数进行比较。模式必须出现在LIKE关键字之后。

  例如，您可以发出以下查询来查找姓名以 开头的所有员工的工资R：

  SELECT salary FROM employees WHERE last_name LIKE 'R%' ORDER BY salary；

  以下查询使用 = 运算符而不是LIKE条件来查找名称为“R%”的所有员工的薪水：

  SELECT salary FROM employees WHERE last_name = 'R%' ORDER BY salary；

  以下查询查找名称为“SM%”的所有员工的工资。KingBase 将 'SM%' 解释为文本文字，而不是模式，因为它位于LIKE关键字之前：

  SELECT salary FROM employees WHERE 'SM%' LIKE last_name ORDER BY salary；

  整理和区分大小写：

  当您使用LIKE搜索索引列的模式时，如果模式中的主要字符不是%或_，KingBase可以使用索引来提高查询的性能。在这种情况下，KingBase可以通过这个主角扫描索引。如果模式中的第一个字符是%或_，则索引不能提高性能，因为KingBase不能扫描索引。

  索引列上的模式匹配：

  当您使用LIKE索引列的模式时，如果模式中的前导字符不是%或_，KingBase 可以使用索引来提高查询的性能。在这种情况下，KingBase 可以通过这个前导字符扫描索引。如果模式中的第一个字符是%or_ ，则索引无法提高性能，因为 Kingbase 无法扫描索引。

  LIKE 条件：一般示例

  此条件适用于以last_name开头的所有值Ma：

  Last_name LIKE 'Ma%'

  所有这些last_name值都使条件为真：

  Mallin、Markle、Marlow、Marvins、Marvis、Matos

  大小写很重要，因此以MA、ma和mA条件开头的last_name值使条件为假。

  考虑这种情况：

  Last_name LIKE 'SMITH'

  last_name对于这些值 ，此条件为真：

  SMITHE，SMITHY，SMITH

  这个条件对于SMITH是假的，因为特殊的下划线字符(_)必须与last_name值的一个字符匹配。

  ESCAPE 子句示例

  以下示例搜索A_B名称中包含该模式的员工：

  SELECT last_name FROM employees WHERE last_name LIKE ‘%A_B%’ ESCAPE ‘’ ORDER BY last_name;

  该ESCAPE子句将反斜杠 () 标识为转义字符。在该模式中，转义字符位于下划线 (_) 之前。这导致 KingBase 按字面意思解释下划线，而不是作为特殊的模式匹配字符。

  没有 % 示例的模式

  如果一个模式不包含该%字符，那么只有当两个操作数的长度相同时，该条件才能成立。考虑该表的定义和插入其中的值：

  CREATE TABLE ducks (f CHAR(6), v VARCHAR2(6));

  INSERT INTO ducks（'DUCK'，'DUCK'）；

  SELECT '*'||f||'*' "char", '*'||v||'*' "varchar" FROM ducks；

  char	varchar
  DUCK	DUCK

  因为 KingBase对空白值进行了CHAR填充，所以f的值被空白填充为 6 个字节。v不是空白填充的，长度为 4。

• REGEXP_LIKE 条件

  REGEXP_LIKE类似于LIKE条件，只是REGEXP_LIKE执行正则表达式匹配，而不是由LIKE执行的简单模式匹配。此条件使用由输入字符集定义的字符来计算字符串。

  regexp_like_condition:

• 

  match_param的值可以包含以下一个或多个字符：

  • 'i'指定不区分大小写的匹配，即使确定的条件排序规则是区分大小写的。

  • 'c'指定区分大小写和区分重音的匹配，即使确定的条件排序规则不区分大小写或不区分重音。

  • 'n'允许句点 (.)，它是匹配任何字符的通配符，来匹配换行符。如果省略此参数，则句点与换行符不匹配。

  • 'm'将源字符串视为多行。KingBase 将 ^和$分别解释为源字符串中任何位置的任何行的开始和结束，而不仅仅是整个源字符串的开始或结束。如果省略此参数，则 KingBase 将源字符串视为单行。

  • 'x'忽略空白字符。默认情况下，空白字符匹配自己。

  如果match_param的值包含多个相互矛盾的字符，则 KingBase 使用最后一个字符。例如，如果您指定'ic'，则 KingBase 使用区分大小写和区分重音的匹配。如果该值包含上述字符以外的字符，则 KingBase 将返回错误。

  如果省略match_param，则：

  • 默认大小写和重音敏感度由确定的REGEXP_LIKE条件排序规则确定。

  • 句点 (.) 与换行符不匹配。

  • 源字符串被视为单行。

  LIKE与条件类似，条件对REGEXP_LIKE排序规则敏感。

  例子：以下查询返回名字为 Steven 或 Stephen 的员工的名字和姓氏（其中first_name开头Ste和结尾en是v或者ph)：

  SELECT first_name，last_name FROM employees WHERE REGEXP_LIKE (first_name, '^Ste(v|ph)en$') ORDER BY first_name,last_name；

  FIRST_NAME	LAST_NAME
  Steven	·King
  Steven	Markle
  Stephen	·stiles

  以下查询返回姓氏中有双元音的员工的姓氏（其中last_name包含两个相邻的a, e, i, o, or u，无论大小写）：

  SELECT last_name FROM employees WHERE REGEXP_LIKE (last_name, '([aeiou])1', 'i') ORDER BY last_name；

  姓
  De Haan
  Greenberg
  Khoo
  Gee
  Greene
  Lee
  Bloom
  Feene

7.6. 空条件

NULL条件测试空值。这是您应该用来测试空值的唯一条件。 null_condition:

下表列出了 null 条件。

条件类型：IS [NOT] NULL， 作用：测试空值。

例子：SELECT last_name FROM employees WHERE commission_pct IS NULL ORDER BY last_name;

7.7. SQL/JSON条件

SQL/JSON 条件允许您测试 JavaScript Object Notation (JSON) 数据，如下所示：

• IS JSON Condition可让您测试表达式是否在语法上是正确的 JSON 数据

• JSON_EXISTS Condition让您测试指定的 JSON 值是否存在于 JSON 数据中

• JSON_TEXTCONTAINS 条件允许您测试指定的字符串是否存在于 JSON 属性值中。

JSON_condition:

• IS JSON Condition

  使用此 SQL/JSON 条件来测试表达式在语法上是否正确或格式正确的 JSON 数据。

  • 如果指定ISJSON，则如果表达式是格式良好的JSON数据，则此条件返回TRUE，如果表达式不是格式良好的JSON数据，则返回false。

  • 如果指定ISNOTJSON，则如果表达式不是格式良好的JSON数据，则返回TRUE；如果表达式是格式良好的JSON数据，则返回false。

  is_JSON_condition:

  

  用于expr指定要评估的 JSON 数据。指定计算结果为文本文字的表达式。如果expr是一列，则该列的数据类型必须为VARCHAR2、CLOB或BLOB。如果expr计算结果为 null 或长度为零的文本文字，则此条件返回UNKNOWN。

  • 如果expr是一个数据类型为BLOB的列，则必须指定格式为JSON。

  • 如果指定严格的，则此条件只考虑严格的JSON语法是格式良好的JSON数据。如果指定LAX，则此条件还将宽松的JSON语法认为是格式良好的JSON数据。默认值为LAX。

  • 如果您指定WITH UNIQUE KEYS，则仅当键名在每个对象中唯一时，此条件才认为 JSON 数据格式正确。如果您指定WITHOUT UNIQUE KEYS，则即使对象中出现重复的键名，此条件也会认为 JSON 数据格式正确。测试比测试执行WITHOUT UNIQUE KEYS得更快WITH UNIQUE KEYS。默认值为WITHOUT UNIQUE KEYS.

  例子：测试 STRICT 或 LAX JSON 语法：示例

  以下语句创建表t：

  CREATE TABLE t (col1 VARCHAR2(100));

  以下语句将值插入到col1表的列中t：

  INSERT INTO t VALUES（'[“LIT192”，“CS141”，“HIS160”]'）；

  INSERT INTO t VALUES（'{“Name”：“John”}'）；

  INSERT INTO t VALUES（'{“Grade Values”：{ A：4.0，B：3.0，C：2.0}}'）；

  INSERT INTO t VALUES ('{ "isEnrolled" : true }' );

  INSERT INTO t VALUES（'{“isMatriculated”：False }'）；

  INSERT INTO t VALUES（NULL）；

  INSERT INTO t VALUES ('This is not well-formed JSON data');

  以下语句查询表t并返回col1格式正确的 JSON 数据的值。由于未指定STRICTnorLAX关键字，因此本示例使用默认LAX设置。因此，此查询返回使用strict或lax JSON 语法的值。

  SELECT col1 FROM T WHERE col1 IS JSON；

  COL1
  [“LIT192”、“CS141”、“HIS160”]
  {“NAME”：“John”}
  {“Grade Values”：{A：4.0，B：3.0，C：2.0}}
  {“isEnrolled”：trye}
  {“isMatriculated”：False}

  以下语句查询表t并返回col1格式正确的 JSON 数据的值。此示例指定STRICT设置。因此，此查询仅返回使用严格 JSON 语法的值。

  SELECT col1 FROM T WHERE coll IS JSON STRICT；

  COL1
  [“LIT192”、“CS141”、“HIS160”]
  {“Name”：“John”}
  {“isEnrolled”：true}

  以下语句查询表t并返回col1使用宽松 JSON 语法的col1值，但省略使用严格 JSON 语法的值。因此，此查询仅返回包含宽松 JSON 语法中允许的异常的值。

  SELECT col1 FROM T WHERE coll IS NOT JSON STRICT AND coll IS JSON LAX；

  COL1
  {“Grade Values”：{A：4.0，B：3.0，C：2.0}}
  {“isMatriculated”：False}

  测试唯一键示例：

  以下语句创建表t：

  CREATE TABLE t (col1 VARCHAR2(100));

  以下语句将值插入到col1表的列中t：

  INSERT INTO t VALUES ('{a:100, b:200, c:300}');

  INSERT INTO t VALUES ('{a:100, a:200, b:300}');

  INSERT INTO t VALUES ('{a:100, b : {a:100, c:300}}');

  以下语句查询表 t 并返回col1具有每个对象内唯一键名的格式良好的 JSON 数据的值：

  SELECT coll FROM t WHERE coll IS JSON WITH UNIQUE KEYS；

  COL1
  {a:100, b:200, c:300}
  {a:100, b : {a:100, c:300}}

  返回第二行，因为虽然键名a出现了两次，但它位于两个不同的对象中。

  以下语句查询表t并返回col1格式正确的 JSON 数据的值，无论每个对象中是否存在唯一键名：

  SELECT coll FROM t WHERE coll IS JSON WITHOUT UNIQUE KEYS；

  COL1
  {a:100, b:200, c:300}
  {a:100, a:200, b:300}
  {a:100, b : {a:100, c:300}}

  使用 IS JSON 作为检查约束示例：

  下面的语句将创建表j_purchaseorder，它将在po_document列中存储JSON数据。该语句使用ISJSON条件作为检查约束，以确保只有格式良好的JSON存储在列po_document中。。

  CREATE TABLE j_purchaseorder (id RAW (16) NOT NULL, date_loaded TIMESTAMP(6) WITH TIME ZONE, po_document CLOB CONSTRAINT ensure_json CHECK (po_document IS JSON));

7.8. 复合条件

复合条件指定其他条件的组合。

复合条件:

7.9. BETWEEN条件

BETWEEN条件确定一个表达式的值是否在由其他两个表达式定义的区间内 。

between_condition:

所有三个表达式都必须是数字、字符或日期时间表达式。在 SQL 中，可能expr1会多次评估。如果BETWEEN表达式出现在 PL/SQL 中，expr1则保证只计算一次。如果表达式不是所有相同的数据类型，则 Kingbase 数据库会将表达式隐式转换为通用数据类型。如果它不能这样做，那么它会返回一个错误。

The value of expr1 NOT BETWEEN expr2 AND expr3

是表达式的值

NOT（expr1 BETWEEN expr2 AND expr3）

和价值

expr1 BETWEEN expr2 AND expr3

是布尔表达式的值：

expr2 <= expr1 AND expr1 <= expr3

如果expr3< expr2，则区间为空。如果expr1是NULL，那么结果是NULL。如果expr1is not NULL，则该值FALSE在普通情况下和TRUE使用关键字时NOT。

布尔运算符AND可能会产生意想不到的结果。具体来说，在表达式x AND y中，条件x IS NULL不足以确定表达式的值。第二个操作数仍然必须被计算。结果是FALSE第二个操作数是否具有值FALSE，NULL否则。

以下为BETWEEN条件简介

条件类型：[NOT] BETWEEN x AND y， 简介：[ NOT]（expr2小于等于expr1 AND expr1小于等于expr3 ）， 例子：SELECT * FROM employees WHERE salary BETWEEn 2000 AND 3000 ORDER BY employee_id;

7.10. EXISTS条件

存在条件测试子查询中是否存在行。

以下介绍了这种EXISTS情况。

条件类型：EXISTS， 如果子查询至少返回一行，则为TRUE。 例子： SELECT department_id FROM departments d WHERE EXISTS （SELECT * FROM employees e WHERE d.department_id = e.department_id) ORDER BY department_id;

7.11. IN条件

in_condition是一个成员条件。它测试值在值或子查询列表中的成员关系。

in_condition:

表达式列表

如果使用in_condition条件的上部形式（在运算符的左边有一个单个表达式），则必须使用expression_list的上部形式。如果使用此条件的较低形式（在运算符的左侧有多个表达式），则必须使用expression_list的较低形式，并且每个expression_list中的表达式必须在数字和数据类型上与运算符左侧的表达式相匹配。

KingBase数据库并不总是按照它们出现在IN列表中的顺序来计算expression_list中的表达式。但是，子查询的选择列表中的表达式将按其指定的顺序进行计算。

以下列出了IN条件的形式。

条件类型：IN，Equal-to-any-member，相当于=。

例子：SELECT * FROM employees WHERE job_id IN ('PU_CLERK','SH_CLERK') ORDER BY employee_id;

SELECT * FROM employees WHERE salary IN （SELECT salary FROM employees WHERE department_id = 30) ORDER BY employee_id;

条件类型：NOT IN， 叙述：相当于 != ALL。如果集合中的任何成员为NULL，则计算为FALSE。

例子：SELECT * FROM employees WHERE salary NOT IN （SELECT salary FROM employees WHERE department_id = 30) ORDER BY employee_id;

SELECT * FROM employees WHERE job_id NOT IN ('PU_CLERK', 'SH_CLERK') ORDER BY employee_id;

如果NOT IN操作后列表中的任何项目计算结果为 null，则所有行计算结果为FALSE或UNKNOWN，并且不返回任何行。例如，以下语句为每一行返回字符串 'True '：

SELECT “TRUE” FROM employees WHERE department_id NOT IN (10, 20);

然而，以下语句不返回任何行：

SELECT “True” FROM employees WHERE department_id NOT IN (10, 20, NULL);

前面的示例不返回任何行，因为WHERE子句条件的计算结果为：

department_id！= 10 AND department_id！= 20 AND department_id！= null

因为第三个条件department_id与 null 比较，所以结果为UNKNOWN，因此整个表达式的结果为FALSE（对于department_id等于 10 或 20 的行）。这种行为很容易被忽略，尤其是当NOT IN操作符引用子查询时。

此外，如果某个NOT IN条件引用了一个根本不返回任何行的子查询，则将返回所有行，如下例所示：

SELECT “TRUE” FROM employees WHERE department_id NOT IN（SELECT 0 FROM DUAL WHERE 1=2）；

对于字符参数，IN条件是排序规则敏感的。核对确定规则确定要使用的核对。

WHERE 子句对 LEVEL 的限制

在子句中的 [ NOT]IN条件中WHERE，如果条件的右侧是子查询，则不能LEVEL在条件的左侧使用。但是，您可以LEVEL在子查询中指定FROM子句来实现相同的结果。例如，以下语句无效：

SELECT employee_id 、last_name FROM employees WHERE (employee_id,LEVEL) WHERE (employee_id, LEVEL) IN (SELECT employee_id, 2 FROM employees) START WHEN employee_id = 2 CONNECT BY PRIOR employee_id = manager_id；

但以下语句是有效的，因为它封装了包含子句 中LEVEL信息的查询：FROM

SELECT v.employee_id、v.last_name、v.lev FROM （SELECT employee_id、last_name、LEVEL lev FROM employees v START WITH employee_id = 100 CONNECT BY PRIOR employee_id = manager_id ) v WHERE（v.employee_id，v.lev）IN (SELECT employee_id，2 FROM employees）；