# 操作符
GaussDB数据库兼容绝大多数MySQL的操作符，但存在部分差异。如未列出，操作符行为默认为GaussDB原生行为，目前存在MySQL不支持但是GaussDB支持的语句，在GaussDB数据库下，这类语句通常为系统内部使用，因此不建议使用。
#### 操作符差异
- ORDER BY排序对NULL值处理的差异。MySQL在排序时会将NULL值排序在前面；GaussDB默认将NULL值默认排在最后面。GaussDB可以通过NULLS FIRST和NULLS LAST设置NULL值排序顺序。
- 有ORDER BY时，除上述特殊场景外，GaussDB输出顺序与MySQL一致。没有ORDER BY时，GaussDB不保证结果顺序与MySQL一致。
- 使用MySQL操作符时需要用括号表达式严格确保表达式的结合性，否则执行报错。例如：SELECT 1 regexp ('12345' regexp '123');。 GaussDB数据库中操作符不用括号严格表达的结合性也能成功执行。
  
- NULL值显示不同。MySQL会将NULL显示为"NULL"；GaussDB将NULL值显示为空值。 MySQL输出结果：
  ```
  mysql> SELECT NULL;
  +------+
  | NULL |
  +------+
  | NULL |
  +------+
  1 row in set (0.00 sec)
  ```
  GaussDB输出结果：
  ```
  m_db=# SELECT NULL;
   ?column? 
  ----------
   
  (1 row)
  ```
  
- 操作符执行后，列名显示不一致。MySQL会将NULL显示为"NULL"；GaussDB将NULL值显示为空值。
- 字符串转double遇到非法字符串时，告警信息不一致。MySQL在常量非法字符串报错，字段非法字符串不报错；GaussDB在常量非法字符串和字段非法字符串都报错。
- 比较操作符返回结果显示不同。MySQL返回1/0；GaussDB返回t/f。
- 当使用比较操作符，对包含NULL值的整型列、时间日期列，与不可转换类型的常量或绑定参数进行比较时，返回结果不同（如date类型与非法日期字符串"1970"、"2023"比较）。MySQL返回NULL；GaussDB返回f。 MySQL输出结果：
  ```
  MySQL > CREATE TABLE test1(t_int int);
  Query OK, 0 rows affected (0.01 sec)
  MySQL > INSERT INTO test1 VALUES(NULL);
  Query OK, 1 row affected (0.00 sec)
  MySQL > SELECT t_int = 1.1 FROM test1;
  +-------------+
  | t_int = 1.1 |
  +-------------+
  |        NULL |
  +-------------+
  1 row in set (0.01 sec)
  MySQL > CREATE TABLE test2(t_date date);
  Query OK, 0 rows affected (0.01 sec)
  MySQL > INSERT INTO test2 VALUES(NULL);
  Query OK, 1 row affected (0.00 sec)
  MySQL > SELECT t_date not in ('1970','2023') FROM test2;
  +-------------------------------+
  | t_date not in ('1970','2023') |
  +-------------------------------+
  |                          NULL |
  +-------------------------------+
  1 row in set, 2 warnings (0.00 sec)
  mysql> DROP TABLE test1;
  Query OK, 0 rows affected (0.01 sec)
  mysql> DROP TABLE test2;
  Query OK, 0 rows affected (0.01 sec)
  ```
  GaussDB输出结果：
  ```
  m_db=# CREATE TABLE test1(t_int int);
  CREATE TABLE
  m_db=# INSERT INTO test1 VALUES(NULL);
  INSERT 0 1
  m_db=# SELECT t_int = 1.1 FROM test1;
   ?column? 
  ----------
   f
  (1 row)
  m_db=# CREATE TABLE test2(t_date date);
  CREATE TABLE
  m_db=# INSERT INTO test2 VALUES(NULL);
  INSERT 0 1
  m_db=# SELECT t_date not in ('1970','2023') FROM test2;
  WARNING:  Incorrect datetime value: '1970'
  WARNING:  Incorrect datetime value: '2023'
   ?column? 
  ----------
   f
  (1 row)
  m_db=# DROP TABLE test1;
  DROP TABLE
  m_db=# DROP TABLE test2;
  DROP TABLE
  ```
  
表1操作符 
| 操作符                                               | 与MySQl的差异                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
|:---|:---|
| \<\>                                           | MySQL支持索引，GaussDB不支持索引。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| \<=\>                                            | MySQL支持索引，GaussDB不支持索引、hash连接和合并连接。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| 行表达式                                            | - MySQL支持\<=\>操作符行比较、GaussDB不支持\<=\>操作符行比较。  - MySQL不支持行表达式与NULL比较。GaussDB支持\<、\<=、=、\>=、\>、\<\>操作符对行表达式与NULL值比较。  - MySQL不支持IS NULL、ISNULL对行表达式的操作。GaussDB支持IS NULL，但不支持ISNULL对行表达式的操作。  - 操作符对于行表达式的不支持的操作，GaussDB错误信息与MySQL不一致。  - MySQL不支持ROW(values)其中values只有一列数据，GaussDB支持。   GaussDB： ``` m_db=# SELECT (1,2) <=> row(2,3); ERROR:  could not determine interpretation of row comparison operator <=> LINE 1: SELECT (1,2) <=> row(2,3); ^ HINT:  unsupported operator. m_db=# SELECT (1,2) < NULL; ?column? ---------- (1 row) m_db=# SELECT (1,2) <> NULL; ?column? ---------- (1 row) m_db=# SELECT (1, 2)  IS NULL; ?column? ---------- f (1 row) m_db=# SELECT ROW(0,0) BETWEEN ROW(1,1) AND ROW(2,2); ERROR:   Unsupport type. m_db=#  SELECT ROW(NULL) AS x; x ---- () (1 row) ``` MySQL: ``` mysql> SELECT (1,2) <=> row(2,3); +--------------------+ | (1,2) <=> row(2,3) | +--------------------+ |                  0 | +--------------------+ 1 row in set (0.00 sec) mysql> SELECT (1,2) < NULL; ERROR 1241 (21000): Operand should contain 2 column(s) mysql> SELECT (1,2) <> NULL; ERROR 1241 (21000): Operand should contain 2 column(s) mysql> SELECT (1, 2)  IS NULL; ERROR 1241 (21000): Operand should contain 1 column(s) mysql> SELECT ISNULL((1, 2)); ERROR 1241 (21000): Operand should contain 1 column(s) mysql> SELECT NULL BETWEEN NULL AND ROW(2,2); ERROR 1241 (21000): Operand should contain 1 column(s) mysql> SELECT ROW(NULL) AS x; ERROR 1064 (42000): You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near ') as x' at line 1 ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| --                                              | m_format_behavior_compat_options不包含forbid_none_space_comment选项时，MySQL表示对一个操作数进行两次取反，结果等于原操作数；GaussDB表示注释。 设置参数m_format_behavior_compat_options包含forbid_none_space_comment选项时，GaussDB与MySQL一致，表示对一个操作数进行两次取反，结果等于原操作数。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| !!                                                 | MySQL：!!含义同!，表示取非。 GaussDB：!表示取非操作，当!与!中间存在空格时，表示连续两次取非（! !）；当!与!中间没有空格时，表示阶乘（!!）。 说明： - GaussDB中，当同时使用阶乘（!!）和取非（!）时，阶乘（!!）和取非（!）中间需要添加空格，否则会报错。  - GaussDB中，当需要多次取非操作时，!与!之间需使用空格隔开。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| \[NOT\] REGEXP                                 | - GaussDB和MySQL在正则表达式中支持的元字符有所不同。例如，GaussDB支持"\\d"表示数字，"\\w"表示字母、数字和下划线，"\\s"表示空格，而MySQL不支持这些元字符，MySQL会把这些字符当成正常字符串。  - GaussDB中"\\b"可以与"\\\\b"匹配，MySQL会匹配失败。  - GaussDB中使用"\\"表示转义字符，而MySQL中使用"\\\\"。  - MySQL不支持2个操作符连在一起使用。  - 模式字符串pattern非法入参，只存在右单括号")"时，GaussDB会报错，MySQL 5.7会报错，MySQL 8.0不会报错。  - 在de\|abc匹配序列de或abc的匹配规则，当\|左右存在空值时，GaussDB不会报错，MySQL 5.7会报错，MySQL 8.0不会报错。  - 制表符"\\t"正则匹配字符类\[:blank:\]，GaussDB可匹配，MySQL 5.7不能匹配，MySQL 8.0可匹配。  - GaussDB支持非贪婪模式匹配，即尽可能少的匹配字符，在部分特殊字符后加"?"问号字符，例如："??, \*?, +?, {n}?, {n,}?, {n,m}?"。MySQL 5.7版本不支持非贪婪模式匹配，并报错：Got error 'repetition-operator operand invalid' from regexp。MySQL 8.0版本已经支持。  - 在BINARY字符集下，TEXT类型、BLOB类型均会转换成BYTEA类型，由于REGEXP操作符不支持BYTEA类型，因此无法匹配。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| LIKE                                             | - MySQL：LIKE的左操作数只能是位运算或者算术运算或者由括号组成的表达式，LIKE的右操作数只能是单目运算符（不含NOT）或者括号组成的表达式。 GaussDB：LIKE的左右操作数可以是任意表达式。   - LIKE的右操作数使用JDBC的setFloat接口绑参，且GaussDB和MySQL的JDBC都使用PBE的方式执行时，GaussDB的查询结果与MySQL存在差异，但对比等价场景------将该setFloat绑参替换成表中float类型数据，GaussDB的行为保持一致，而MySQL自身的行为不一致。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| \[NOT\] BETWEEN AND                              | MySQL：\[NOT\] BETWEEN AND嵌套使用时从右到左结合。\[NOT\] BETWEEN AND的第1个操作数和第2个操作数只能是位运算或者算术运算或者由括号组成的表达式。 GaussDB：\[NOT\] BETWEEN AND嵌套使用时从左到右结合。\[NOT\] BETWEEN AND的第1个操作数和第2个操作数可以是任意表达式。在GUC参数m_format_behavior_compat_options中配置了between_and_independent_compare时，不同的比较对象分别进行独立比较，并选择合适的比较类型。 在一些特殊场景下（例如表达式中包含repeat()函数），MySQL的\[NOT\] BETWEEN AND可能与\[NOT\] ( \>= AND \<= )的等价操作结果不一致，而GaussDB将会优先保证与\[NOT\] ( \>= AND \<= )的等价操作结果保持一致，因此会存在差异。 ``` -- GaussDB BETWEEN AND 与 (>= AND <=) 行为一致 m_db=# CREATE TABLE test_between(c0 YEAR); CREATE TABLE m_db=# INSERT INTO test_between(c0) VALUES('1963'); INSERT 0 1 m_db=# SELECT (''<>'Lt') BETWEEN '' AND c0 AS ref0 FROM test_between; ref0 ------ f (1 row) m_db=# SELECT (''<>'Lt') >= '' AND (''<>'Lt') <= c0 AS ref0 FROM test_between; ref0 ------ f (1 row) m_db=# DROP TABLE test_between; DROP TABLE -- MYSQL: BETWEEN AND行为与 (>= AND <=) 行为不一致 mysql> CREATE TABLE test_between(c0 YEAR); Query OK, 0 rows affected (0.03 sec) mysql> INSERT INTO test_between(c0) VALUES('1963'); Query OK, 1 row affected (0.00 sec) mysql> SELECT (''<>'Lt') BETWEEN '' AND c0 AS ref0 FROM test_between; +------+ | ref0 | +------+ |    1 | +------+ 1 row in set (0.00 sec) mysql> SELECT (''<>'Lt') >= '' AND (''<>'Lt') <= c0 AS ref0 FROM test_between; +------+ | ref0 | +------+ |    0 | +------+ 1 row in set (0.00 sec) mysql> DROP TABLE test_between; Query OK, 0 rows affected (0.01 sec) ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| IN                                             | MySQL：IN的左操作数只能是位运算或者算术运算或者由括号组成的表达式。 GaussDB：IN的左操作数可以是任意表达式。对于ROW IN (ROW,ROW....)形式的查询，未兼容MySQL，与其行为存在较大差异，不建议使用。 在开启精度传递的场景下，对表中的数据使用in操作符时，若表中数据为FLOAT类型、DOUBLE类型且包括相应精度和标度（如float(4,2)，double(4,2)）,GaussDB会根据精度和标度对值进行比较，MySQL会读取内存值（失真数值，导致比较不相等）。 ``` --GaussDB： m_db=# CREATE TABLE test1(t_float float(4,2)); CREATE TABLE m_db=# INSERT INTO test1 VALUES(1.42),(2.42); INSERT 0 2 m_db=# SELECT t_float, t_float in (1.42,2.42) FROM test1; t_float | ?column? ---------+---------- 1.42 | t 2.42 | t (2 rows) --MySQL： mysql> CREATE TABLE test1(t_float float(4,2)); Query OK, 0 rows affected (0.01 sec) mysql> INSERT INTO test1 VALUES(1.42),(2.42); Query OK, 2 rows affected (0.00 sec) Records: 2  Duplicates: 0  Warnings: 0 mysql> SELECT t_float, t_float in (1.42,2.42) FROM test1; +---------+------------------------+ | t_float | t_float in (1.42,2.42) | +---------+------------------------+ |    1.42 |                      0 | |    2.42 |                      0 | +---------+------------------------+ 2 rows in set (0.00 sec) ``` 在in多列col in (col1, col2, ...)场景中，MySQL的结果存在不自洽情况，与单列col in (col1) or col in (col2) or ... 结果存在差异，以单列结果为准。 ``` -- GaussDB m_db=# CREATE TABLE T_IN(C1 time(6)); CREATE TABLE m_db=# INSERT INTO T_IN VALUES(0); INSERT 0 1 m_db=# SELECT C1 FROM T_IN WHERE C1 IN ('0000-00-00'); WARNING:  Incorrect time value: '0000-00-00' C1 ---- (0 rows) m_db=# SELECT C1 FROM T_IN WHERE C1 IN (20230101101112.100000); WARNING:  Incorrect time value: '20230101101112.100000' C1 ---- (0 rows) m_db=# SELECT C1 FROM T_IN WHERE C1 IN ('0000-00-00') OR C1 IN (20230101101112.100000); WARNING:  Incorrect time value: '0000-00-00' WARNING:  Incorrect time value: '20230101101112.100000' C1 ---- (0 rows) m_db=# SELECT C1 FROM T_IN where C1 IN ('0000-00-00', 20230101101112.100000); WARNING:  Incorrect time value: '0000-00-00' WARNING:  Incorrect time value: '20230101101112.100000' WARNING:  Incorrect time value: '0000-00-00' C1 ---- (0 rows) m_db=# DROP TABLE T_IN; DROP TABLE -- MySQL mysql> CREATE TABLE T_IN(C1 time(6)); Query OK, 0 rows affected (0.02 sec) mysql> INSERT INTO T_IN VALUES(0); Query OK, 1 row affected (0.00 sec) mysql> SELECT C1 FROM T_IN WHERE C1 IN ('0000-00-00'); Empty set, 1 warning (0.00 sec) mysql> SELECT C1 FROM T_IN WHERE C1 IN (20230101101112.100000); Empty set, 1 warning (0.00 sec) mysql> SELECT C1 FROM T_IN WHERE C1 IN ('0000-00-00') OR C1 IN (20230101101112.100000); Empty set, 2 warnings (0.01 sec) mysql> SELECT C1 FROM T_IN where C1 IN ('0000-00-00', 20230101101112.100000); +-----------------+ | C1              | +-----------------+ | 00:00:00.000000 | +-----------------+ 1 row in set, 1 warning (0.00 sec) mysql> DROP TABLE T_IN; Query OK, 0 rows affected (0.01 sec) ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| ！                                               | MySQL：!的操作数只能是单目运算符（不含not）或者括号组成的表达式。 GaussDB：!的操作数可以是任意表达式。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| #                                               | MySQL支持#注释，GaussDB不支持#注释。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| BINARY                                          | GaussDB中支持的表达式和MySQL并不完全一致（包括一些函数、操作符等）。GaussDB独有的表达式"\~"、"IS DISTINCT FROM"等，由于BINARY关键字优先级更高，使用BINARY expr会优先将BINARY与"\~"、"IS DISTINCT FROM"的左参数合并，导致报错。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| 取负（-）                                           | 取反结果类型和精度与MySQL不一致： ``` CREATE TABLE t AS SELECT - -1; ``` - MySQL表字段返回类型为：decimal(2,0)。  - GaussDB表字段返回类型为：integer(1)。   在开启精度传递（m_format_behavior_compat_options = 'enable_precision_decimal'）的情况下，负号加常量数据类型的精度可能与MySQL存在差异，MySQL 5.7中，当表达式中包含取反操作符时，结果精度中的最大长度（max_length）会根据表达式中取反操作符的数量增加，而GaussDB不会。例如： - GaussDB： ``` m_db=# DROP TABLE IF EXISTS test; NOTICE:  table "test" does not exist, skipping DROP TABLE m_db=# CREATE TABLE test as m_db-# SELECT format(-4.4600e3,1) f9; INSERT 0 1 m_db=# DESC test; Field |    Type     | Null | Key | Default | Extra -------+-------------+------+-----+---------+------- f9    | varchar(45) | YES  |     |         | (1 row) m_db=# DROP TABLE IF EXISTS t1; NOTICE:  table "t1" does not exist, skipping DROP TABLE m_db=# CREATE TABLE t1 AS SELECT cast(- -4.46 AS BINARY) c4,convert(- - -002.2600,BINARY) c14; INSERT 0 1 m_db=# DESC t1; Field |     Type      | Null | Key | Default | Extra -------+---------------+------+-----+---------+------- c4    | varbinary(5)  | YES  |     |         | c14   | varbinary(10) | YES  |     |         | (2 rows) m_db=# DROP VIEW IF EXISTS v2; NOTICE:  view "v2" does not exist, skipping DROP VIEW m_db=# CREATE VIEW v2 AS SELECT cast(- -4.46 AS BINARY) c4,convert(- - -002.2600,BINARY) c14; CREATE VIEW m_db=# DESC v2; Field |     Type     | Null | Key | Default | Extra -------+--------------+------+-----+---------+------- c4    | varbinary(5) | YES  |     |         | c14   | varbinary(8) | YES  |     |         | (2 rows) ```   - MySQL： ``` mysql> DROP TABLE IF EXISTS test; Query OK, 0 rows affected (0.01 sec) mysql> CREATE TABLE test AS -> SELECT format(-4.4600e3,1) f9; Query OK, 1 row affected (0.01 sec) Records: 1  Duplicates: 0  Warnings: 0 mysql> DESC test; +-------+-------------+------+-----+---------+-------+ | Field | Type        | Null | Key | Default | Extra | +-------+-------------+------+-----+---------+-------+ | f9    | varchar(63) | YES  |     | NULL    |       | +-------+-------------+------+-----+---------+-------+ 1 row in set (0.00 sec) mysql> DROP TABLE IF EXISTS t1; Query OK, 0 rows affected, 1 warning (0.00 sec) mysql> CREATE TABLE t1 AS SELECT cast(- -4.46 AS BINARY) c4,convert(- - -002.2600,BINARY) c14; Query OK, 1 row affected (0.02 sec) Records: 1  Duplicates: 0  Warnings: 0 mysql> DESC t1; +-------+---------------+------+-----+---------+-------+ | Field | Type          | Null | Key | Default | Extra | +-------+---------------+------+-----+---------+-------+ | c4    | varbinary(7)  | YES  |     | NULL    |       | | c14   | varbinary(12) | YES  |     | NULL    |       | +-------+---------------+------+-----+---------+-------+ 2 rows in set (0.00 sec) mysql> DROP VIEW IF EXISTS v2; Query OK, 0 rows affected, 1 warning (0.00 sec) mysql> CREATE VIEW v2 AS SELECT cast(- -4.46 AS BINARY) c4,convert(- - -002.2600,BINARY) c14; Query OK, 0 rows affected (0.03 sec) mysql> DESC v2; +-------+---------------+------+-----+---------+-------+ | Field | Type          | Null | Key | Default | Extra | +-------+---------------+------+-----+---------+-------+ | c4    | varbinary(7)  | YES  |     | NULL    |       | | c14   | varbinary(10) | YES  |     | NULL    |       | +-------+---------------+------+-----+---------+-------+ 2 rows in set (0.00 sec) ```    |
| /\*\*/                                          | GaussDB中语句中不支持/\*\*/注释。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| xor                                            | GaussDB的xor和MySQL的行为不同。GaussDB优化器会有常数优化，会出现先计算表示结果是常数的情况。 GaussDB: ``` m_db=#  SELECT 1 xor null xor pow(200, 2000000) FROM dual; ERROR:   The value is out of range, and an overflow occurred. m_db=# CREATE TABLE t1(a int, b int); CREATE TABLE m_db=# INSERT INTO t1 VALUES(2,2), (200, 2000000000); INSERT 0 2 m_db=# m_db=# m_db=# SELECT 1 xor null xor pow(a, b) FROM t1; ?column? ---------- (2 rows) ``` MySQL: ``` mysql>  SELECT 1 xor null xor pow(200, 2000000) FROM dual; +----------------------------------+ | 1 xor null xor pow(200, 2000000) | +----------------------------------+ |                             NULL | +----------------------------------+ 1 row in set (0.00 sec) ysql> CREATE TABLE t1(a int, b int); Query OK, 0 rows affected (0.04 sec) mysql> INSERT INTO t1 VALUES(2,2), (200, 2000000000); Query OK, 2 rows affected (0.01 sec) Records: 2  Duplicates: 0  Warnings: 0 mysql>  SELECT 1 xor null xor pow(a, b) FROM t1; +--------------------------+ | 1 xor null xor pow(a, b) | +--------------------------+ |                     NULL | |                     NULL | +--------------------------+ 2 rows in set (0.00 sec) ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| IS NULL和IS NOT NULL                              | MySQL的优先级小于逻辑运算符，GaussDB的优先级大于逻辑运算符。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| AND（\&\&）、OR（\|\|）、XOR、\|、\&、\<、\>、\<=、\>=、=、!= | MySQL执行机制为执行左操作数后，对结果进行判断是否为空，进而决定是否需要执行右操作数。 GaussDB执行机制是执行左右操作数后，对结果再进行判断是否为空。 当左操作数结果为空，右操作数执行报错时，MySQL不会报错直接返回，GaussDB会执行报错。 MySQL行为： ``` mysql> SELECT version(); +------------------+ | version()        | +------------------+ | 5.7.44-debug-log | +------------------+ 1 row in set (0.00 sec) mysql> DROP TABLE IF EXISTS data_type_table; Query OK, 0 rows affected (0.02 sec) mysql> CREATE TABLE data_type_table ( -> MyBool BOOL, -> MyBinary BINARY(10), -> MyYear YEAR -> ); Query OK, 0 rows affected (0.02 sec) mysql> INSERT INTO data_type_table VALUES (TRUE, 0x1234567890, '2021'); Query OK, 1 row affected (0.00 sec) mysql> SELECT (MyBool % MyBinary) | (MyBool - MyYear) FROM data_type_table; +-----------------------------------------+ | (MyBool % MyBinary) | (MyBool - MyYear) | +-----------------------------------------+ |                                    NULL | +-----------------------------------------+ 1 row in set, 2 warnings (0.00 sec) ``` GaussDB行为： ``` m_db=# DROP TABLE IF EXISTS data_type_table; DROP TABLE m_db=# CREATE TABLE data_type_table ( m_db, m_db; CREATE TABLE m_db=# INSERT INTO data_type_table VALUES (TRUE, 0x1234567890, '2021'); INSERT 0 1 m_db=# SELECT (MyBool % MyBinary) | (MyBool - MyYear) FROM data_type_table; WARNING:  The double value '4Vx     ' is incorrect. CONTEXT:  referenced column: (MyBool % MyBinary) | (MyBool - MyYear) WARNING:  Division by zero. CONTEXT:  referenced column: (MyBool % MyBinary) | (MyBool - MyYear) ERROR:  Bigint is out of range. CONTEXT:  referenced column: (MyBool % MyBinary) | (MyBool - MyYear) ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| +、-、\*、 /、%、mod、div                               | CREATE VIEW AS SELECT算数操作符（'+', '-', '\*', '/', '%', 'mod', 'div'）内嵌b''常量时，MySQL 5.7返回类型可能存在unsigned标识，GaussDB不会。 MySQL输出结果： ``` mysql> CREATE VIEW v22 as SELECT b'101' / b'101' c22; Query OK, 0 rows affected (0.00 sec) mysql> DESC v22; +-------+-----------------------+------+-----+---------+-------+ | Field | Type                  | Null | Key | Default | Extra | +-------+-----------------------+------+-----+---------+-------+ | c22   | decimal(5,4) unsigned | YES  |     | NULL    |       | +-------+-----------------------+------+-----+---------+-------+ 1 row in set (0.01 sec) ``` GaussDB输出结果： ``` m_db=# CREATE VIEW v22 AS SELECT b'101' / b'101' c22; CREATE VIEW m_db=# DESC v22; Field |     Type     | Null | Key | Default | Extra -------+--------------+------+-----+---------+------- c22   | decimal(5,4) | YES  |     |         | (1 row) ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
   
表2操作符组合差异 
| 操作符组合示例                                   | MySQL数据库 | GaussDB数据库 | 说明                                         |
|:---|:---|:---|:---|
| SELECT 1 LIKE 3 \& 1;                      | 不支持       | 支持         | LIKE的右操作数不能是位运算符组成的表达式。                  |
| SELECT 1 LIKE 1 +1;                       | 不支持       | 支持          | LIKE的右操作数不能是算术运算符组成的表达式。                    |
| SELECT 1 LIKE NOT 0;                       | 不支持        | 支持           | LIKE的右操作数只能是+、-、!等单目操作符或者括号组成的表达式，NOT除外。 |
| SELECT 1 BETWEEN 1 AND 2 BETWEEN 2 AND 3; | 从右到左结合     | 从左到右结合      | 建议加上括号明确运算的优先级，防止由于运算顺序的差异导致运算结果产生偏差。     |
| SELECT 2 BETWEEN 1=1 AND 3;                 | 不支持         | 支持           | BETWEEN的第2个操作数不能是比较操作符组成的表达式。             |
| SELECT 0 LIKE 0 BETWEEN 1 AND 2;           | 不支持       | 支持           | BETWEEN的第1个操作数不能是模式匹配操作符组成的表达式。            |
| SELECT 1 IN (1) BETWEEN 0 AND 3;            | 不支持       | 支持        | BETWEEN的第1个操作数不能是IN操作符组成的表达式。            |
| SELECT 1 IN (1) IN (1);                      | 不支持        | 支持          | 第2个IN表达式左操作数不能是IN组成的表达式。                   |
| SELECT ! NOT 1;                            | 不支持       | 支持            | !的操作数只能是+、-、!等单目操作符或者括号组成的表达式，NOT除外。      |
   
#### 索引差异
- GaussDB当前仅支持UBTree和B-tree索引。
- 在执行LIKE模糊匹配，并通过EXPLAIN打印执行计划时，执行计划中会显示当前索引列对应字符序的最小/最大字符权重编码。该编码在不同的客户端字符集设置下的显示可能存在差异，但不影响LIKE模糊匹配查询结果的正确性。
- B-tree/UBTree索引场景保持原生GaussDB原有逻辑，即同一操作符族内的类型比较，支持索引扫描，其余索引类型暂未支持。
- 在使用GaussDB JDBC连接数据库时，GaussDB的YEAR类型在含有绑定参数的PBE场景下无法利用索引。
- 部分函数在操作符表达式中嵌套时，返回值类型会发生隐式转换。如果函数返回值类型转换后与表达式索引的类型不一致，将无法使用索引扫描。
- WHERE子句中，索引字段类型和常量类型操作场景下，GaussDB中索引与MySQL索引支持存在差异，如[表3]所示。例如以下语句GaussDB不支持索引：
  ```
  CREATE TABLE t(_int int);
  CREATE INDEX idx ON t(_int) USING BTREE;
  SELECT * FROM t WHERE _int >  2.0;
  ```
  ![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
  - WHERE子句里索引字段类型和常量类型操作场景中，可以使用cast函数将常数类型显式转换为字段类型，以便实现索引。
    ```
    SELECT * FROM t WHERE _int > cast(2.0 AS signed);
    ```
    
  
  
  
  - 在执行LIKE模糊匹配时，单字节字符集场景下，GaussDB创建前缀索引长度最长为2676字节，MySQL创建前缀索引长度最长为3072字节。当超过最大长度时，建议创建非前缀索引。
   
   表3索引支持差异 
  | 索引字段类型     | 常量类型                | GaussDB是否支持走索引 | MySQL是否支持走索引 |
  |:---|:---|:---|:---|
  | BIT类型      | BIT类型              | 否              | 是          |
  | BIT类型      | 整型                  | 否               | 是           |
  | BIT类型      | 浮点型                  | 否             | 是            |
  | BIT类型      | 定点型               | 否               | 是           |
  | BIT类型      | 字符串类型               | 否               | 是            |
  | BIT类型      | 二进制类型               | 否               | 是          |
  | BIT类型      | 带日期的时间类型               | 否                 | 否               |
  | BIT类型      | TIME类型              | 否              | 是          |
  | BIT类型      | YEAR类型             | 否             | 是         |
  | SET/ENUM类型 | 字符串类型             | 否              | 否           |
  | SET/ENUM类型 | 二进制类型               | 否              | 否          |
  | SET/ENUM类型 | 整型                   | 否              | 否             |
  | SET/ENUM类型 | 浮点型                  | 否              | 否           |
  | SET/ENUM类型 | 定点型                 | 否               | 否            |
  | SET/ENUM类型 | 带日期的时间类型           | 否               | 否           |
  | SET/ENUM类型 | TIME类型            | 否               | 否           |
  | SET/ENUM类型 | YEAR类型              | 否               | 否           |
  | TIME类型       | TIME类型               | 是               | 是            |
  | TIME类型       | 带日期的时间类型            | 是            | 是             |
  | TIME类型       | YEAR类型               | 是              | 是             |
  | TIME类型       | 整型（可转为TIME类型）        | 是              | 是            |
  | TIME类型       | 整型（不可转为TIME类型）       | 否              | 否           |
  | TIME类型       | 字符串类型（可转为TIME类型）   | 是               | 是           |
  | TIME类型       | 字符串类型（不可转为TIME类型）    | 否              | 否          |
  | TIME类型       | 二进制类型（可转为TIME类型）  | 是              | 是         |
  | TIME类型       | 二进制类型（不可转为TIME类型）    | 否                | 否           |
  | TIME类型       | 浮点型（可转为TIME类型）       | 是              | 是            |
  | TIME类型       | 浮点型（不可转为TIME类型）      | 否              | 否             |
  | TIME类型       | 定点型（可转为TIME类型）      | 是             | 是         |
  | TIME类型       | 定点型（不可转为TIME类型）    | 否               | 否            |
  | YEAR类型       | YEAR类型             | 是              | 是             |
  | YEAR类型       | 整型（可转为YEAR类型）       | 是              | 是             |
  | YEAR类型       | 整型（不可转为YEAR类型，负数）  | 否              | 是           |
  | YEAR类型       | 浮点型（可转为YEAR类型）      | 是                | 是           |
  | YEAR类型       | 浮点型（不可转为YEAR类型）    | 否                | 否             |
  | YEAR类型       | 定点型（可转为YEAR类型）    | 是               | 是            |
  | YEAR类型       | 定点型（不可转为YEAR类型）   | 否                 | 否            |
  | YEAR类型       | 字符串类型（可转为YEAR类型）     | 是              | 是           |
  | YEAR类型       | 字符串类型（不可转为YEAR类型）     | 否               | 否            |
  | YEAR类型       | 二进制类型（可转为YEAR类型）    | 是            | 是           |
  | YEAR类型       | 二进制类型（不可转为YEAR类型）  | 否              | 否           |
  | YEAR类型       | 带日期的时间类型              | 否             | 是          |
  | YEAR类型       | TIME类型              | 否              | 是           |
  | 带日期的时间类型   | 带日期的时间类型             | 是            | 是             |
  | 带日期的时间类型   | TIME类型              | 是              | 是          |
  | 带日期的时间类型   | YEAR类型                | 是              | 否             |
  | 带日期的时间类型   | 整型（可转为带日期的时间类型）     | 是                | 是           |
  | 带日期的时间类型   | 整型（不可转为带日期的时间类型）    | 否               | 否            |
  | 带日期的时间类型   | 浮点型（可转为带日期的时间类型）   | 是              | 是          |
  | 带日期的时间类型   | 浮点型（不可转为带日期的时间类型）   | 否              | 否           |
  | 带日期的时间类型   | 定点型（可转为带日期的时间类型）  | 是              | 是           |
  | 带日期的时间类型   | 定点型（不可转为带日期的时间类型）    | 否             | 否          |
  | 带日期的时间类型   | 字符串类型（可转为带日期的时间类型）   | 是              | 是          |
  | 带日期的时间类型   | 字符串类型（不可转为带日期的时间类型） | 否              | 否         |
  | 带日期的时间类型   | 二进制类型（可转为带日期的时间类型） | 是              | 是            |
  | 带日期的时间类型   | 二进制类型（不可转为带日期的时间类型） | 否               | 否            |
  | 定点型        | 定点型                | 是              | 是          |
  | 定点型        | 整型                   | 是                | 是           |
  | 定点型        | 浮点型                 | 否             | 是           |
  | 定点型        | 字符串类型               | 否               | 是         |
  | 定点型        | 二进制类型               | 否               | 是           |
  | 定点型        | 带日期的时间类型              | 否              | 是            |
  | 定点型        | TIME类型               | 否              | 是            |
  | 定点型        | YEAR类型             | 是             | 是           |
  | 浮点型        | 浮点型               | 是              | 是           |
  | 浮点型        | 整型                | 是                | 是          |
  | 浮点型        | 定点型                 | 是               | 是           |
  | 浮点型        | 字符串类型              | 是             | 是            |
  | 浮点型        | 二进制类型               | 是             | 是            |
  | 浮点型        | 带日期的时间类型             | 是              | 是          |
  | 浮点型        | TIME类型             | 是            | 是          |
  | 浮点型        | YEAR类型               | 是               | 是          |
  | 整型           | 整型                   | 是             | 是           |
  | 整型           | 浮点型                  | 否              | 是           |
  | 整型           | 定点型                | 是             | 是          |
  | 整型           | 字符串类型 (可转为整型）     | 是             | 是           |
  | 整型           | 字符串类型 (不可转为整型）       | 否              | 是          |
  | 整型           | 二进制类型 (可转为整型）      | 是               | 是             |
  | 整型           | 二进制类型 (不可转为整型）     | 否             | 是          |
  | 整型           | 带日期的时间类型           | 是              | 是           |
  | 整型           | TIME类型            | 是             | 是            |
  | 整型           | YEAR类型              | 是            | 是           |
  | 二进制类型        | 二进制类型               | 是               | 是           |
  | 二进制类型        | 字符串类型               | 是              | 是          |
  | 二进制类型        | 带日期的时间类型           | 否              | 否           |
  | 二进制类型        | TIME类型             | 是                | 否           |
  | 二进制类型        | YEAR类型              | 否             | 否             |
  | 二进制类型        | 整型                  | 否              | 否           |
  | 二进制类型        | 浮点型                  | 否             | 否            |
  | 二进制类型        | 定点型                | 否              | 否          |
  | 字符串类型        | 字符串类型              | 是             | 是             |
  | 字符串类型        | 带日期的时间类型              | 否              | 否           |
  | 字符串类型        | TIME类型            | 是              | 否           |
  | 字符串类型        | YEAR类型              | 否              | 否           |
  | 字符串类型        | 二进制类型              | 否              | 否           |
  | 字符串类型        | 整型                   | 否               | 否           |
  | 字符串类型        | 浮点型                | 否               | 否           |
  | 字符串类型        | 定点型                 | 否              | 否           |
     
  ![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
  - 仅在GUC参数m_format_behavior_compat_options未开启disable_int_cmp_num_index选项时，支持整型索引字段与定点型常量比较时，可以执行索引。
  
  - 整型索引字段与定点型常量比较执行索引场景中，要求定点型常量不能为用户自定义变量、CASE WHEN表达式或子查询返回值。
    
 
