### 12.4.2 比较函数和运算符

[](<>)

[](<>)

**表 12.4 比较运算符**

| 姓名 | 描述 |
| --- | --- |
| [`>`](comparison-operators.html#operator_greater-than) | 大于运算符 |
| [`>=`](comparison-operators.html#operator_greater-than-or-equal) | 大于或等于运算符 |
| [`<`](comparison-operators.html#operator_less-than) | 小于运算符 |
| [`<>`, `!=`](comparison-operators.html#operator_not-equal) | 不等于运算符 |
| [`<=`](comparison-operators.html#operator_less-than-or-equal) | 小于或等于运算符 |
| [`<=>`](comparison-operators.html#operator_equal-to) | NULL 安全等于运算符 |
| [`=`](comparison-operators.html#operator_equal) | 等号运算符 |
| [`之间 ...`](comparison-operators.html#operator_between) | 一个值是否在一个值范围内 |
| [`合并（）`](comparison-operators.html#function_coalesce) | 返回第一个非 NULL 参数 |
| [`最伟大的（）`](comparison-operators.html#function_greatest) | 返回最大的参数 |
| [`在（）`](comparison-operators.html#operator_in) | 一个值是否在一组值内 |
| [`间隔（）`](comparison-operators.html#function_interval) | 返回小于第一个参数的参数的索引 |
| [`是`](comparison-operators.html#operator_is) | 根据布尔值测试值 |
| [`不是`](comparison-operators.html#operator_is-not) | 根据布尔值测试值 |
| [`不为空`](comparison-operators.html#operator_is-not-null) | NOT NULL 值测试 |
| [`一片空白`](comparison-operators.html#operator_is-null) | 空值测试 |
| [`一片空白（）`](comparison-operators.html#function_isnull) | 测试参数是否为 NULL |
| [`至少（）`](comparison-operators.html#function_least) | 返回最小的参数 |
| [`喜欢`](string-comparison-functions.html#operator_like) | 简单的模式匹配 |
| [`不在……和……之间`](comparison-operators.html#operator_not-between) | 值是否不在值范围内 |
| [`不在（）`](comparison-operators.html#operator_not-in) | 一个值是否不在一组值内 |
| [`不喜欢`](string-comparison-functions.html#operator_not-like) | 简单模式匹配的否定 |
| [`STRCMP()`](string-comparison-functions.html#function_strcmp) | 比较两个字符串 |

[](<>)[](<>)

比较运算的结果为`1` (`真的`), `0` (`错误的`）， 要么`空值`.这些操作适用于数字和字符串。必要时，字符串会自动转换为数字，数字会自动转换为字符串。

以下关系比较运算符不仅可用于比较标量操作数，还可用于比较行操作数：

```
=  >  <  >=  <=  <>  !=
```

本节后面对这些运算符的描述详细说明了它们如何处理行操作数。有关行子查询上下文中行比较的其他示例，请参阅[第 13.2.11.5 节，“行子查询”](row-subqueries.html).

本节中的某些函数返回的值不是`1`(`真的`),`0`(`错误的`）， 要么`空值`.[`至少（）`](comparison-operators.html#function_least)和[`最伟大的（）`](comparison-operators.html#function_greatest)是此类功能的示例；[第 12.3 节，“表达式求值中的类型转换”](type-conversion.html)，描述了由这些和类似函数执行的比较操作的规则，以确定它们的返回值。

笔记

在以前版本的 MySQL 中，当评估一个包含`至少（）`要么`最伟大的（）`，服务器试图猜测使用函数的上下文，并将函数的参数强制转换为整个表达式的数据类型。例如，参数`最少（“11”、“45”、“2”）`作为字符串进行计算和排序，以便此表达式返回`"11"`.在MySQL 8.0.3及更早版本中，当计算表达式时`最小值（“11”、“45”、“2”）+0`，服务器在对参数进行排序之前将其转换为整数（预期结果中会添加整数0），从而返回2。

从MySQL 8.0.4开始，服务器不再试图以这种方式推断上下文。相反，该函数是使用提供的参数执行的，当且仅当一个或多个参数不是同一类型时，才对它们执行数据类型转换。现在，由使用返回值的表达式强制执行的任何类型强制都将在函数执行后执行。这意味着，在MySQl 8.0.4及更高版本中，`最小值（“11”、“45”、“2”）+0`评估为`"11" + 0`也就是整数11。（臭虫#83895，臭虫#25123839）

要将值转换为特定类型以进行比较，可以使用[`演员阵容`](cast-functions.html#function_cast)作用可以使用以下命令将字符串值转换为不同的字符集：[`CONVERT（）`](cast-functions.html#function_convert)看见[第12.11节，“转换函数和运算符”](cast-functions.html).

默认情况下，字符串比较不区分大小写，并使用当前字符集。默认值是`utf8mb4`.

-   [](<>)

    [`=`](comparison-operators.html#operator_equal)

    [](<>)[](<>)

    相等：

    ```
    mysql> SELECT 1 = 0;
            -> 0
    mysql> SELECT '0' = 0;
            -> 1
    mysql> SELECT '0.0' = 0;
            -> 1
    mysql> SELECT '0.01' = 0;
            -> 0
    mysql> SELECT '.01' = 0.01;
            -> 1
    ```

    对于行比较，`（a，b）=（x，y）`相当于：

    ```
    (a = x) AND (b = y)
    ```

-   [](<>)

    [`<=>`](comparison-operators.html#operator_equal-to)

    [](<>)[](<>)

    `无效的`-安全平等。此运算符执行与[`=`](comparison-operators.html#operator_equal)接线员，但返回`1.`而不是`无效的`如果两个操作数都是`无效的`和`0`而不是`无效的`如果一个操作数是`无效的`.

    [](<>)

    这个[`<=>`](comparison-operators.html#operator_equal-to)运算符相当于标准SQL`与…没有区别`操作人员

    ```
    mysql> SELECT 1 <=> 1, NULL <=> NULL, 1 <=> NULL;
            -> 1, 1, 0
    mysql> SELECT 1 = 1, NULL = NULL, 1 = NULL;
            -> 1, NULL, NULL
    ```

    对于行比较，`（a，b）<=>（x，y）`相当于：

    ```
    (a <=> x) AND (b <=> y)
    ```

-   [](<>)

    [`<>`](comparison-operators.html#operator_not-equal), [`!=`](comparison-operators.html#operator_not-equal)

    [](<>)[](<>)[](<>)[](<>)

    不平等：

    ```
    mysql> SELECT '.01' <> '0.01';
            -> 1
    mysql> SELECT .01 <> '0.01';
            -> 0
    mysql> SELECT 'zapp' <> 'zappp';
            -> 1
    ```

    对于行比较，`（a，b）<>（x，y）`和`（a，b）！=（x，y）`相当于：

    ```
    (a <> x) OR (b <> y)
    ```

-   [](<>)

    [`<=`](comparison-operators.html#operator_less-than-or-equal)

    [](<>)[](<>)

    小于或等于：

    ```
    mysql> SELECT 0.1 <= 2;
            -> 1
    ```

    对于行比较，`（a，b）<=（x，y）`相当于：

    ```
    (a < x) OR ((a = x) AND (b <= y))
    ```

-   [](<>)

    [`<`](comparison-operators.html#operator_less-than)

    [](<>)[](<>)

    少于：

    ```
    mysql> SELECT 2 < 2;
            -> 0
    ```

    对于行比较，`（a，b）<（x，y）`相当于：

    ```
    (a < x) OR ((a = x) AND (b < y))
    ```

-   [](<>)

    [`>=`](comparison-operators.html#operator_greater-than-or-equal)

    [](<>)[](<>)

    大于或等于：

    ```
    mysql> SELECT 2 >= 2;
            -> 1
    ```

    对于行比较，`（a，b）>=（x，y）`相当于：

    ```
    (a > x) OR ((a = x) AND (b >= y))
    ```

-   [](<>)

    [`>`](comparison-operators.html#operator_greater-than)

    [](<>)[](<>)

    大于：

    ```
    mysql> SELECT 2 > 2;
            -> 0
    ```

    对于行比较，`（a，b）>（x，y）`相当于：

    ```
    (a > x) OR ((a = x) AND (b > y))
    ```

-   [](<>)

    [`*`expr`*中间*`闵`*及*`最大值`*`](comparison-operators.html#operator_between)

    [](<>)

    如果*`expr`*大于或等于*`闵`*和*`expr`*小于或等于*`最大值`*, [`之间`](comparison-operators.html#operator_between)返回`1.`，否则它会返回`0`.这相当于`(*`闵`* <= *`expr`*及*`expr`* <= *`最大值`*)`如果所有参数的类型相同。否则，将根据中描述的规则进行类型转换[第12.3节，“表达式计算中的类型转换”](type-conversion.html)，但适用于所有三个论点。

    ```
    mysql> SELECT 2 BETWEEN 1 AND 3, 2 BETWEEN 3 and 1;
            -> 1, 0
    mysql> SELECT 1 BETWEEN 2 AND 3;
            -> 0
    mysql> SELECT 'b' BETWEEN 'a' AND 'c';
            -> 1
    mysql> SELECT 2 BETWEEN 2 AND '3';
            -> 1
    mysql> SELECT 2 BETWEEN 2 AND 'x-3';
            -> 0
    ```

    为了在使用时获得最佳效果[`之间`](comparison-operators.html#operator_between)对于日期或时间值，使用[`演员阵容`](cast-functions.html#function_cast)将值显式转换为所需的数据类型。例子：如果你比较[`约会时间`](datetime.html)两个[`日期`](datetime.html)值，将[`日期`](datetime.html)价值观[`约会时间`](datetime.html)价值观如果使用字符串常量，例如`'2001-1-1'`与[`日期`](datetime.html)，将弦抛向[`日期`](datetime.html).

-   [](<>)

    [`*`expr`*不在中间*`闵`*及*`最大值`*`](comparison-operators.html#operator_not-between)

    [](<>)

    这和`不是(*`expr`*中间*`闵`*及*`最大值`*)`.

-   [](<>)

    [`结合(*`价值`*,...)`](comparison-operators.html#function_coalesce)

    [](<>)[](<>)

    返回第一个非-`无效的`列表中的值，或`无效的`如果没有非-`无效的`价值观

    返回类型[`聚结`](comparison-operators.html#function_coalesce)是参数类型的聚合类型。

    ```
    mysql> SELECT COALESCE(NULL,1);
            -> 1
    mysql> SELECT COALESCE(NULL,NULL,NULL);
            -> NULL
    ```

-   [](<>)

    [`伟大的(*`价值1`*,*`价值2`*,...)`](comparison-operators.html#function_greatest)

    [](<>)

    对于两个或多个参数，返回最大（最大值）参数。参数的比较使用的规则与[`至少`](comparison-operators.html#function_least).

    ```
    mysql> SELECT GREATEST(2,0);
            -> 2
    mysql> SELECT GREATEST(34.0,3.0,5.0,767.0);
            -> 767.0
    mysql> SELECT GREATEST('B','A','C');
            -> 'C'
    ```

    [`最伟大的`](comparison-operators.html#function_greatest)返回`无效的`如果有任何论据`无效的`.

-   [](<>)

    [`*`expr`*在(*`价值`*,...)`](comparison-operators.html#operator_in)

    [](<>)

    退换商品`1.`（正确）如果*`expr`*等于`在（）`列表，否则返回`0`（错）。

    类型转换根据中描述的规则进行[第12.3节，“表达式计算中的类型转换”](type-conversion.html)，适用于所有论点。如果中的值不需要类型转换`在（）`名单上，他们都不是-`JSON`相同类型的常量，以及*`expr`*如果可以将它们作为同一类型的值（可能在类型转换后）进行比较，则会进行优化。列表中的值已排序，搜索*`expr`*使用二进制搜索完成，这使得`在（）`行动很快。

    ```
    mysql> SELECT 2 IN (0,3,5,7);
            -> 0
    mysql> SELECT 'wefwf' IN ('wee','wefwf','weg');
            -> 1
    ```

    `在（）`可用于比较行构造函数：

    ```
    mysql> SELECT (3,4) IN ((1,2), (3,4));
            -> 1
    mysql> SELECT (3,4) IN ((1,2), (3,5));
            -> 0
    ```

    千万不要在一个表中混用引号和未引号的值`在（）`列表，因为带引号的值（如字符串）和不带引号的值（如数字）的比较规则不同。因此，混合类型可能会导致不一致的结果。例如，不要写`在（）`表达方式如下：

    ```
    SELECT val1 FROM tbl1 WHERE val1 IN (1,2,'a');
    ```

    而是这样写：

    ```
    SELECT val1 FROM tbl1 WHERE val1 IN ('1','2','a');
    ```

    隐式类型转换可能会产生非直观的结果：

    ```
    mysql> SELECT 'a' IN (0), 0 IN ('b');
            -> 1, 1
    ```

    在这两种情况下，比较值都会转换为浮点值，每种情况下都会产生0.0，比较结果为1（true）。

    表中的值数`在（）`名单仅限于[`最大允许包数`](server-system-variables.html#sysvar_max_allowed_packet)价值

    为了符合SQL标准，`在（）`返回`无效的`如果左边的表达式是`无效的`，但如果在列表中找不到匹配项且列表中的一个表达式为`无效的`.

    `在（）`语法也可用于编写某些类型的子查询。看见[第13.2.11.3节，“带有任意、IN或部分的子查询”](any-in-some-subqueries.html).

-   [](<>)

    [`*`expr`*不在(*`价值`*,...)`](comparison-operators.html#operator_not-in)

    [](<>)

    这和`不是(*`expr`*在(*`价值`*,...))`.

-   [](<>)

    [`间歇(*`N`*,*`N1`*,*`N2`*,*`N3`*,...)`](comparison-operators.html#function_interval)

    [](<>)

    退换商品`0`如果*`N`* \\\< *`N1`*, `1.`如果*`N`* \\\< *`N2`*等等`-1`如果*`N`*是`无效的`.所有参数都被视为整数。要求*`N1`* \\\< *`N2`* \\\< *`N3`* \\\< `...` \\\< *`Nn`*使此功能正常工作。这是因为使用了二进制搜索（非常快）。

    ```
    mysql> SELECT INTERVAL(23, 1, 15, 17, 30, 44, 200);
            -> 3
    mysql> SELECT INTERVAL(10, 1, 10, 100, 1000);
            -> 2
    mysql> SELECT INTERVAL(22, 23, 30, 44, 200);
            -> 0
    ```

-   [](<>)

    [`是吗*`布尔值`*`](comparison-operators.html#operator_is)

    [](<>)[](<>)[](<>)[](<>)

    根据布尔值测试值，其中*`布尔值`*可以是`符合事实的`, `错误的`或`未知的`.

    ```
    mysql> SELECT 1 IS TRUE, 0 IS FALSE, NULL IS UNKNOWN;
            -> 1, 1, 1
    ```

-   [](<>)

    [`不是*`布尔值`*`](comparison-operators.html#operator_is-not)

    [](<>)[](<>)[](<>)[](<>)

    根据布尔值测试值，其中*`布尔值`*可以是`符合事实的`, `错误的`或`未知的`.

    ```
    mysql> SELECT 1 IS NOT UNKNOWN, 0 IS NOT UNKNOWN, NULL IS NOT UNKNOWN;
            -> 1, 1, 0
    ```

-   [](<>)

    [`是空的`](comparison-operators.html#operator_is-null)

    [](<>)[](<>)

    测试某个值是否正确`无效的`.

    ```
    mysql> SELECT 1 IS NULL, 0 IS NULL, NULL IS NULL;
            -> 0, 0, 1
    ```

    为了更好地使用ODBC程序，MySQL在使用[`是空的`](comparison-operators.html#operator_is-null):

    [](<>)[](<>)

    -   如果[`sql_auto_为空`](server-system-variables.html#sysvar_sql_auto_is_null)变量设置为1，然后在成功插入自动生成的`自动增量`值，您可以通过发出以下形式的语句来找到该值：

        ```
        SELECT * FROM tbl_name WHERE auto_col IS NULL
        ```

        如果语句返回一行，则返回的值与调用[`最后插入ID（）`](information-functions.html#function_last-insert-id)作用有关详细信息，包括多行插入后的返回值，请参见[第12.16节“信息功能”](information-functions.html).如果没有`自动增量`值已成功插入，则[`选择`](select.html)语句不返回任何行。

        检索数据的行为`自动增量`通过使用[`是空的`](comparison-operators.html#operator_is-null)可以通过设置禁用比较[`sql_auto_为_null=0`](server-system-variables.html#sysvar_sql_auto_is_null)看见[第5.1.8节“服务器系统变量”](server-system-variables.html).

        的默认值[`sql_auto_为空`](server-system-variables.html#sysvar_sql_auto_is_null)是0。

    -   对于[`日期`](datetime.html)和[`约会时间`](datetime.html)声明为`非空`，你可以找到特别的日期`'0000-00-00'`使用这样的语句：

        ```
        SELECT * FROM tbl_name WHERE date_column IS NULL
        ```

        这是让一些ODBC应用程序工作所必需的，因为ODBC不支持`'0000-00-00'`日期值。

        看见[获取自动增量值](https://dev.mysql.com/doc/connector-odbc/en/connector-odbc-usagenotes-functionality-last-insert-id.html)，以及`标志自动为空`选择在[连接器/ODBC连接参数](https://dev.mysql.com/doc/connector-odbc/en/connector-odbc-configuration-connection-parameters.html).

-   [](<>)

    [`不是空的`](comparison-operators.html#operator_is-null)

    [](<>)[](<>)

    测试值是否为空`无效的`.

    ```
    mysql> SELECT 1 IS NOT NULL, 0 IS NOT NULL, NULL IS NOT NULL;
            -> 1, 1, 0
    ```

-   [](<>)

    [`一片空白（*`表达式`*)`](comparison-operators.html#function_isnull)

    [](<>)

    如果*`表达式`*是`空值`,[`一片空白（）`](comparison-operators.html#function_isnull)返回`1`, 否则返回`0`.

    ```
    mysql> SELECT ISNULL(1+1);
            -> 0
    mysql> SELECT ISNULL(1/0);
            -> 1
    ```

    [`一片空白（）`](comparison-operators.html#function_isnull)可以用来代替[`=`](comparison-operators.html#operator_equal)测试一个值是否是`空值`.（比较一个值`空值`使用[`=`](comparison-operators.html#operator_equal)总是产生`空值`.)

    这[`一片空白（）`](comparison-operators.html#function_isnull)函数与[`一片空白`](comparison-operators.html#operator_is-null)比较运算符。见描述[`一片空白`](comparison-operators.html#operator_is-null).

-   [](<>)

    [`至少（*`价值1`*,*`价值2`*,...)`](comparison-operators.html#function_least)

    [](<>)

    使用两个或多个参数，返回最小（最小值）参数。使用以下规则比较参数：

    -   如果有任何论据`空值`，结果是`空值`.不需要比较。

    -   如果所有参数都是整数值，则将它们作为整数进行比较。

    -   如果至少一个参数是双精度的，则将它们作为双精度值进行比较。否则，如果至少一个参数是[`十进制`](fixed-point-types.html)值，它们被比较为[`十进制`](fixed-point-types.html)价值观。

    -   如果参数包含数字和字符串的混合，则将它们作为字符串进行比较。

    -   如果任何参数是非二进制（字符）字符串，则将参数作为非二进制字符串进行比较。

    -   在所有其他情况下，参数作为二进制字符串进行比较。

        的返回类型[`至少（）`](comparison-operators.html#function_least)是比较参数类型的聚合类型。

    ```
    mysql> SELECT LEAST(2,0);
            -> 0
    mysql> SELECT LEAST(34.0,3.0,5.0,767.0);
            -> 3.0
    mysql> SELECT LEAST('B','A','C');
            -> 'A'
    ```
