# 单行函数
| Oracle数据库                                                 | GaussDB数据库 |
|:---|:---|
| [表1]   | 支持，有差异      |
| [表2] | 支持，有差异       |
| [表3]   | 支持，有差异       |
| 字符集函数                                                       | 不支持           |
| Collation函数                                              | 不支持         |
| [表4]    | 支持，有差异       |
| [表5]      | 支持，有差异       |
| [表6]    | 支持，有差异      |
| [表7]      | 支持，有差异      |
| 集合函数                                                       | 不支持         |
| [表8]     | 支持         |
| 数据挖掘功能函数                                                   | 不支持         |
| [表9]    | 支持，有差异      |
| [表10]    | 支持，有差异      |
| [表11]  | 支持，有差异    |
| [表12]    | 支持          |
| [表13] | 支持，有差异     |
   
 表1数值函数 
| Oracle数据库     | GaussDB数据库 | 差异                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
|:---|:---|:---|
| ABS         | 支持         | -                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| ACOS         | 支持，有差异        | 当参数为BINARY_DOUBLE或BINARY_FLOAT类型且值的范围不在-1\~1之间时，GaussDB报错，Oracle返回NaN。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| ASIN       | 支持，有差异      | 当参数为BINARY_DOUBLE或BINARY_FLOAT类型且值的范围不在-1\~1之间时，GaussDB报错，Oracle返回NaN。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| ATAN          | 支持           | -                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| ATAN2       | 支持，有差异     | 两个参数都为0时，GaussDB返回0，Oracle报错。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| BITAND      | 支持，有差异       | - GaussDB入参最大支持BIGINT范围，Oracle入参可支持NUMBER范围。  - 当参数包含小数时，GaussDB四舍五入取整后进行计算，而Oracle截断取整后进行计算。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| CEIL        | 支持          | -                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| COS           | 支持，有差异      | - 返回值数据类型和精度不同。 GaussDB：返回值类型是float8，结果精度保留15位有效数字。 Oracle：返回值类型是number。     - 参数值为Infinity或-Infinity时，GaussDB报错，Oracle返回NaN。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| COSH        | 支持，有差异      | 返回值数据类型和精度不同。 GaussDB：当输入是numeric时，返回numeric类型；当输入是其他类型时，返回float8类型，结果精度保留15位有效数字。 Oracle：返回值类型是number。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| EXP         | 支持           | -                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| FLOOR       | 支持           | 返回值类型不同： Gaussdb: - 当其中一个输入是numeric时，返回numeric类型。  - 其他数据类型，返回float8类型。   Oracle: - 返回值类型是numeric。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| LN           | 支持          | 返回值不同： - Oracle返回结果保留小数点后37位，GaussDB返回结果保留小数点后15位。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| LOG          | 支持          | 入参类型不同： - GaussDB对非法入参进行了判断，如NaN 0.0 -Infinity 0 Infinity等。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| MOD        | 支持，有差异        | - 返回类型不一致，Oracle数据库类型包括BINARY_DOUBLE，BINARY_FLOAT，NUMBER；GaussDB返回类型包括int2，int4，int8，numeric。  - 返回值不同，当入参为包含小数的字符串类型（如'2.5'）时，Oracle将其隐式转换为NUMBER类型，保留小数部分进行计算；GaussDB将其隐式转换为整数类型，小数部分四舍五入进行计算，导致结果与Oracle不一致。  - 当第一个入参为数值类型时，第二个参数必须为int、numeric类型或能够转换为numeric的类型。在a_format_version为10c，a_format_dev_version为s6时，当第一个参数为能够转为numeric的text类型时，第二个参数必须为不超过int4的数值类型或者纯数字的字符类型。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| NANVL       | 支持，有差异       | GaussDB不支持直接声明或浮点数除0得到NaN。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| POWER        | 支持，有差异     | 返回值数据类型不同。 GaussDB： - 当其中一个输入是numeric时，返回numeric类型。当numeric结果小于10\^16时，直接返回0。  - 其他数据类型，返回float8类型。   Oracle： 返回值类型是number。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| REMAINDER     | 支持，有差异       | 返回值数据类型不同。 GaussDB： - 当一个输入是float4时，另一个是numeric时，返回float4类型。  - 当两个输入都是float4时，返回float4类型。  - 当两个输入都是float8时，返回float8类型。  - 当两个输入都是字符数值类型时，返回float8类型。  - 其他数据类型，返回numeric   Oracle： 返回值类型是number。 返回结果不一致： - Oracle用ROUND取商，GaussDB用FLOOR取商，当n2/n1小数部分为0.5时两者取整方向不同，导致余数结果不一致。   |
| ROUND       | 支持，有差异        | - 第一个参数n的float类型，GaussDB存在精度损失，比Oracle数据库精度低。  - 返回类型不一致。round(n, integer)形式，Oracle数据库NUMBER类型，GaussDB返回numeric类型；round(n)形式，Oracle数据库n的数据类型，GaussDB只能返回float8和numeric类型，缺少float4返回类型。  - GaussDB判断入参有null，执行框架返回null的逻辑与Oracle数据库不一致。 ``` SELECT round(NULL,'q'); ``` Oracle数据库null，GaussDB报错invalid input syntax for integer: "q"。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| SIGN         | 支持，有差异       | 返回值数据类型不同。 GaussDB：当输入是numeric时，返回numeric类型，否则返回float8类型。 Oracle：返回值类型是number。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| SIN         | 支持，有差异        | - 返回值数据类型和精度不同。 GaussDB：返回值类型是float8，结果精度保留15位有效数字。 Oracle：返回值类型是number。     - 参数值为Infinity或-Infinity时，GaussDB报错，Oracle返回NaN。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| SINH       | 支持，有差异      | 返回值数据类型和精度不同。 GaussDB：当输入是numeric时，返回numeric类型；当输入是其他类型时，返回float8类型，结果精度保留15位有效数字。 Oracle：返回值类型是number。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| SQRT        | 支持          | -                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| TAN         | 支持，有差异      | - 返回值数据类型和精度不同。 GaussDB：返回值类型是float8，结果精度保留15位有效数字。 Oracle：返回值类型是number。     - 参数值为Infinity或-Infinity时，GaussDB报错，Oracle返回NaN。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| TANH        | 支持，有差异       | 返回值数据类型和精度不同。 GaussDB：当输入是numeric时，返回numeric类型；当输入是其他类型时，返回float8类型，结果精度保留15位有效数字。 Oracle：返回值类型是number。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| TRUNC        | 支持           | 入参类型不同： - GaussDB第二个入参为text类型，第一个入参须为时间类型。   返回值类型不同： - GaussDB入参个数为1个且不是numetic的数值类型时，返回值类型为loat8类型。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| WIDTH_BUCKET | 支持          | 入参类型不同： GaussDB： - 不支持入参为时间类型。  - 函数最后一个入参类型不支持科学计数法。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
   
 表2返回字符值的字符函数 
| Oracle数据库     | GaussDB数据库 | 差异                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
|:---|:---|:---|
| CHR           | 支持，有差异     | - 输入的数字不符合现有字符集时，在JDBC下GaussDB会报错，Oracle数据库会返回乱码。  - 输入0、256等时Oracle数据库会返回Ascii码为0的字符，GaussDB会在'\\0;处截断。  - 当入参为(-1,1)区间内的小数时，在GaussDB中，参数会被取整为0，函数输出为null；而在Oracle中，则会报错，提示参数超出范围。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| CONCAT          | 支持，有差异     | - 函数返回类型差异：GaussDB返回类型为text；而Oracle则根据输入参数的类型动态决定返回类型。    - 对于非法字符的拼接，GaussDB不会检查字符的合法性，直接拼接所有字符；而Oracle若检测到非法字符，会忽略该字符。\|\|操作符也存在类似的差异。 示例： ``` -- GaussDB gaussdb=# SET a_format_version='10c'; SET gaussdb=#  SET a_format_dev_version='s2'; SET gaussdb=# SELECT dump(CHR(239) || 'test') FROM dual; dump ----------------------------------- Typ=25 Len=5: 239,116,101,115,116 (1 row) -- Oracle SQL> SELECT dump(CHR(239) || 'test') FROM dual; dump(CHR(239)||'TEST') ----------------------------------------------- Typ=1 Len=4: 116,101,115,116 ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| INITCAP         | 支持，有差异       | 返回值受限于数据库字符集，导致返回结果与Oracle数据库不一致。当入参为EMPTY_CLOB()时，GaussDB返回空字符串；Oracle返回null。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| LOWER          | 支持，有差异    | - 返回值类型不一致，Oracle数据库和输入类型一致的数据类型。  - 对时间格式上隐式转换问题，输入时间类型时，隐式转换为字符串再进行lower操作。 ``` SELECT LOWER(TO_DATE('2012-12-10','YYYY-MM-DD')); ``` Oracle返回10-DEC-12，GaussDB返回2012-12-10 00:00:00。   - 返回值受限于数据库字符集，导致返回结果与Oracle数据库不一致。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| LPAD          | 支持，有差异     | - GaussDB返回类型为text，当第二个参数超过int范围时，会报错；Oracle返回类型为varchar2，第二个参数超过int范围时会根据varchar2的最大长度截断为4000个字符，并正常输出结果。  - 对于非法字符的处理，Oracle会直接填充非法字符；而GaussDB会先检查字符的合法性，如果是非法字符，则会报错。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| LTRIM         | 支持，有差异    | - 返回值类型不一致。当输入为字符数据类型时，Oracle返回VARCHAR2类型；输入为数据库创建时指定的国家字符集时，Oracle返回NVARCHAR2类型；输入为LOB类型时，Oracle返回LOB类型，GaussDB返回TEXT类型。  - 当源字符串为EMPTY_CLOB()时，Oracle返回空字符；GaussDB返回null。  - Oracle仅支持删除单个字符；GaussDB支持删除字符串。  - 当删除字符为EMPTY_CLOB()时，Oracle直接返回null；GaussDB将其视为删除空字符，返回源字符串。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| NCHR           | 支持，有差异      | - 返回值字节长度与Oracle数据库不一致。  - 返回值受限于数据库字符集，导致返回结果与Oracle数据库不一致。  - 返回入参对应的字节数组时，单个字节在\[0x80-0xFF\]范围，会返回"?"，Oracle数据库返回"?"、或者不输出、或者会报错。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| NLS_LOWER       | 支持，有差异     | - 返回值类型不同，输入为字符数据类型时，Oracle返回VARCHAR2类型；输入为LOB类型时，Oracle返回LOB类型，GaussDB返回TEXT类型。  - nlsparam参数Oracle数据库还可以传入除nls_sort外的其他参数种类而不报错，GaussDB只支持nls_sort。  - 返回值受限于数据库字符集，导致返回结果与Oracle数据库不一致。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| NLS_UPPER     | 支持，有差异      | - 返回值类型不同，输入为字符数据类型时，Oracle返回VARCHAR2类型；输入为LOB类型时，Oracle返回LOB类型，GaussDB返回TEXT类型。  - nlsparam参数Oracle数据库还可以传入除nls_sort外的其他参数种类而不报错，GaussDB只支持nls_sort。  - 返回值受限于数据库字符集，导致返回结果与Oracle数据库不一致。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| NLSSORT         | 支持        | -                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| REGEXP_REPLACE   | 支持，有差异     | - GaussDB入参source_char不支持NCLOB、BLOB、XMLTYPE类型。  - 入参match_param选项 'n' 含义有差异：GaussDB中 'n' 选项与 'm' 选项含义相同，表示采用多行模式匹配；而 Oracle 表示 (.) 能匹配 '\\n' 字符，没有指定该选项时默认不能匹配 '\\n' 字符。GaussDB中 (.) 默认匹配 '\\n' 选项，不需要指定选项。  - 不同正则表达式匹配结果可能不一致。 ``` SELECT REGEXP_REPLACE('abc01234xyz', '(.*?)(\d+)(.*)', '#', 'g') FROM DUAL; ``` Oracle报错，GaussDB返回#####xyz。   - 在UTF-8编码字符集下中文输入时匹配结果可能不一致。Oracle需要在GBK字符集实现中文字符串的正则表达式匹配。  - 包含部分转义字符的正则表达式匹配结果可能不一致。 ``` SELECT REGEXP_REPLACE('abcabc', '\abc', '#', 'g') FROM DUAL; ``` Oracle报错，GaussDB返回abcabc。   - 匹配规则受aformat_regexp_match参数影响，具体影响规格请参见[字符处理函数和操作符](https://support.huaweicloud.com/distributed-ref-v10-gaussdb/gaussdb-08-0041.html)章节REGEXP_REPLACE函数部分。    - 正则表达式中如果字符类\[\]中包含转义字符（例如\\t、\\n、\\r、\\s、\\d、\\w等），GaussDB会将其转义成制表符；Oracle将其视为普通字符，不进行转义。  - 对于不完整的正则表达式（例如'{2,'等），GaussDB会严格验证正则表达式的正确性并报错；Oracle将其视为普通字符。  - 第四个、第五个参数的取整方式不同：GaussDB采取四舍五入处理；Oracle采取截断取整处理。  - GaussDB不支持正则表达式\[A-Z\]??问号数量超过三个；Oracle支持。  - GaussDB支持正则表达式长度超过512；Oracle不支持。  - 当输入四个参数时，GaussDB的第四个参数不支持字符串形式的数字；Oracle支持。  - GaussDB支持 (?:...) 非捕获组语法；Oracle不支持。   |
| REGEXP_SUBSTR | 支持，有差异    | - 匹配规则受aformat_regexp_match参数影响，具体影响规格请参见[字符处理函数和操作符](https://support.huaweicloud.com/distributed-ref-v10-gaussdb/gaussdb-08-0041.html)章节REGEXP_SUBSTR函数部分。  - GaussDB对于正则表达式A{1,xxx}的最大值限制在255以内。  - GaussDB中对于正则表达式 'x' 模式，会将CHR(9)制表符或CHR(10)换行符视为空白忽略；Oracle将其视为普通匹配字符处理。  - GaussDB不支持六个参数的输入。  - GaussDB支持将0\~1的小数作为第三个参数，Oracle不支持。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| REPLACE       | 支持，有差异     | - GaussDB不支持XMLTYPE类型的输入，Oracle支持。  - GaussDB不支持BLOB类型的输入，Oracle支持。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| RPAD            | 支持，有差异     | - GaussDB返回类型为text，当第二个参数超过int范围时，会报错；Oracle返回类型为varchar2，第二个参数超过int范围时会根据varchar2的最大长度截断为4000个字符，并正常输出结果。  - 对于非法字符的处理，Oracle会直接填充非法字符；而GaussDB会先检查字符的合法性，如果是非法字符，则会报错。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| RTRIM           | 支持，有差异       | - 当源字符串为EMPTY_CLOB()时，Oracle返回空字符；GaussDB返回null。  - Oracle仅支持删除单个字符；GaussDB支持删除字符串。  - 当删除字符为EMPTY_CLOB()时，Oracle直接返回null；GaussDB将其视为删除空字符，返回源字符串。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| SUBSTR           | 支持，有差异    | - 当源字符串参数为EMPTY_CLOB()时，GaussDB返回null，Oracle返回空clob。  - 当第二个参数或第三个参数为带小数位的数值时，GaussDB采用四舍五入处理，Oracle采用取整处理。  - 当第二个参数初始index超过源字符串的总长度时，GaussDB报错，Oracle返回null。  - GaussDB不支持将字符串的科学表达式（如'1E2'）作为第二个或第三个参数，Oracle支持。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| TRANSLATE      | 支持，有差异     | 当源字符串为EMPTY_CLOB()时，GaussDB返回空字符串；Oracle返回null。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| TRIM          | 支持，有差异     | - 当源字符串为EMPTY_CLOB()时，Oracle返回空字符；GaussDB返回null。    - Oracle要求FROM前必须指定截取方向关键字或截取字符参数，不能省略；GaussDB支持省略FROM前所有参数。  - Oracle仅支持删除单个字符；GaussDB支持删除字符串。    - 当删除字符为EMPTY_CLOB()时，Oracle直接返回null；GaussDB将其视为删除空字符，返回源字符串。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| UPPER           | 支持，有差异      | - 返回值类型不一致，Oracle数据库和输入类型一致的数据类型，GaussDB返回TEXT类型。  - 对时间格式上隐式转换问题，输入时间类型时，隐式转换为字符串再进行upper操作。 ``` SELECT UPPER(TO_DATE('2012-12-10','YYYY-MM-DD')); ``` Oracle返回10-DEC-12，GaussDB返回2012-12-10 00:00:00。   - 返回值受限于数据库字符集，导致返回结果与Oracle数据库不一致。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| REVERSE         | 支持，有差异      | - Oracle不支持clob、NUMBER、DATE、TIMESTAMP、TIMESTAMPTZ、INTERVAL、float、double数据类型的输入，GaussDB支持。  - 对于多字节字符，Oracle按照字节进行反转，转换后会出现乱码；GaussDB按照字符转换。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| INSTRB         | 支持         | -                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
   
 表3返回数值的字符函数 
| Oracle数据库     | GaussDB数据库 | 差异                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
|:---|:---|:---|
| ASCII        | 支持，有差异     | - 返回值类型不同。Oracle数据库返回类型为uint4，GaussDB为int4。  - 对于非法字符的处理，GaussDB会先检验是否为非法字符（如0x80）；Oracle则相对宽松，会返回非法字符的ASCII码。  - 当入参为EMPTY_CLOB()时，GaussDB返回0；Oracle返回null。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| INSTR         | 支持，有差异       | - GaussDB的第三个参数类型为int；Oracle为numeric。  - GaussDB的第三、四个参数小数点的进位规则不同，GaussDB采用四舍五入处理；Oracle采用整数截断处理。  - Oracle的第四个参数因为是截断整数，当为负数和0\~1的小数时，截断结果是0或负数，当为非法次数时，会报错；GaussDB不报错，直接返回0。  - GaussDB不支持json类型作为源参数。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| LENGTH        | 支持，有差异     | 返回值类型不同，Oracle返回numeric，GaussDB返回int。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| LENGTHB     | 支持，有差异   | GaussDB仅支持文本字符串类型入参，不接受BLOB类型；Oracle支持BLOB类型入参。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| REGEXP_COUNT | 支持，有差异     | - GaussDB入参source_char不支持NCLOB类型。  - 入参match_param选项 'n' 含义有差异：GaussDB中 'n' 选项与 'm' 选项含义相同，表示采用多行模式匹配；而 Oracle 表示 (.) 能匹配 '\\n' 字符，没有指定该选项时默认不能匹配 '\\n' 字符。GaussDB中 (.) 默认匹配 '\\n' 选项，不需要指定选项。  - 不同正则表达式匹配结果可能不一致。  - 在UTF-8编码字符集下中文输入时匹配结果可能不一致。Oracle需要在GBK字符集实现中文字符串的正则表达式匹配。  - 包含部分转义字符的正则表达式匹配结果可能不一致。  - 匹配规则受aformat_regexp_match参数影响，具体影响规格请参见[字符处理函数和操作符](https://support.huaweicloud.com/distributed-ref-v10-gaussdb/gaussdb-08-0041.html)章节REGEXP_COUNT函数部分。  - GaussDB支持 (?:...) 非捕获组语法，Oracle不支持。  - 在x 扩展模式下，GaussDB会忽略模式中的空白字符（空格、制表符等）和注释；Oracle不支持忽略。  - 正则表达式为未定义的转义字符如'\\x'等，GaussDB会报错；Oracle会将其退化为普通字符进行匹配。  - 当标记为m时，如果源字符串中存在拼接的CHR(10)，返回结果存在差异：Oracle不会统计最后一行。  - \[\[:blank:\]\]在GaussDB中可以匹配CHR(9)；Oracle无法匹配。   |
| REGEXP_INSTR   | 支持，有差异     | - 匹配规则受aformat_regexp_match参数影响，具体影响规格请参见[字符处理函数和操作符](https://support.huaweicloud.com/distributed-ref-v10-gaussdb/gaussdb-08-0041.html)章节REGEXP_INSTR函数部分。  - 正则表达式差异，\\s在字符类\[...\]中的行为：GaussDB正则引擎（基于POSIX ERE/Perl风格）支持在\[\]内使用\\s作为空白字符类，\\s = \[ \\t\\n\\r\\f\\v\]（所有空白字符）；Oracle正则引擎不支持在\[\]内使用\\s作为"空白字符类"。  - 参数类型： - GaussDB不支持将BLOB类型作为源字符串参数；Oracle支持。  - GaussDB的第三个、第四个、第五个参数类型为int，且超过int范围会报错；Oracle为numeric。    - 取整方式：GaussDB的第三个、第四个、第五个参数采用四舍五入处理，Oracle采用截断整数处理。  - 参数个数：GaussDB不支持七个参数的输入，Oracle支持。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| REGEXP_LIKE   | 支持，有差异     | - GaussDB不支持'n'等标识参数。  - 对于错误的正则表达式，GaussDB报错，Oracle返回false。  - GaussDB的正则表达式不支持'\^X{4000}$' 大于255。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| LENGTHC        | 支持            | -                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| DUMP           | 支持，有差异     | - 第二个、第三个或第四个参数为null时：GaussDB直接返回null；Oracle使用默认值，第二个参数默认为10，第三个参数默认为1，第四个参数默认为全部（即读取表达式的所有字节）。  - 参数类型： - GaussDB不支持xmltype、name类型作为第一个参数；Oracle支持。  - GaussDB的第二个、第三个、第四个参数类型为int；Oracle为numeric。    - 取整方式：GaussDB的第二个、第三个、第四个参数采用四舍五入处理；Oracle采用取整处理。  - 源输入为null时：GaussDB返回null；Oracle返回'NULL'字符串。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
   
 表4日期时间函数 
| Oracle数据库       | GaussDB数据库 | 差异                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
|:---|:---|:---|
| ADD_MONTHS       | 支持，有差异      | - 公元后到公元前，GaussDB会和Oracle数据库相差1年。  - GaussDB的计算结果范围可以到-4714年，Oracle数据库只到-4713年。  - 当输入字符类型字面量时，GaussDB会优先选择timestamp的重载函数，而Oracle只存在入参为date类型的函数。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| CURRENT_DATE     | 支持，有差异      | - GaussDB不支持nls_date_format参数设置时间显示格式。  - 开启mapping_date_to_datea时，current_date返回值为datea类型，关闭mapping_date_to_datea时，current_date返回date类型。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| CURRENT_TIMESTAMP | 支持，有差异    | Oracle数据库参数支持范围（0 \~ 9）。 GaussDB支持范围（0 \~ 6），微秒末位零不显示。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| DBTIMEZONE      | 支持，有差异       | GaussDB不支持自带tz的timestamp类型接口的调用。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| EXTRACT           | 支持          | -                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| LAST_DAY          | 支持，有差异        | GaussDB存在入参为datea类型和timestamp类型的两个重载函数，当输入字符类型字面量时，GaussDB会优先选择timestamp的重载函数，而Oracle只存在入参为date类型的函数。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| LOCALTIMESTAMP    | 支持，有差异     | Oracle数据库参数支持范围（0 \~ 9）。 GaussDB支持范围（0 \~ 6），微秒末位零不显示。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| MONTHS_BETWEEN   | 支持，有差异     | GaussDB存在入参为datea类型和timestamp类型的两个重载函数，当输入字符类型字面量时，GaussDB会优先选择timestamp的重载函数，而Oracle只存在入参为date类型的函数。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| NEW_TIME          | 支持，有差异       | GaussDB存在入参为datea类型和timestamp类型的两个重载函数，当输入字符类型字面量时，GaussDB会优先选择timestamp的重载函数，而Oracle只存在入参为date类型的函数。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| NEXT_DAY           | 支持            | GaussDB存在入参为datea类型和timestamp类型的两个重载函数，输入字符类型字面量时，GaussDB会优先选择timestamp的重载函数，而Oracle只存在入参为date类型的函数。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| NUMTODSINTERVAL   | 支持，有差异       | GaussDB不支持dsinterval类型，暂时用interval兼容dsinterval类型。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| NUMTOYMINTERVAL   | 支持，有差异       | - GaussDB不支持yminterval类型，暂时用interval兼容yminterval类型。  - GaussDB不支持BLOB类型作为入参。  - 由于浮点数取整存在差异，导致入参为浮点数时，返回结果存在差异。 ``` -- Oracle SQL> SELECT NUMTOYMINTERVAL(0.01, 'YEAR') FROM DUAL; NUMTOYMINTERVAL(0.01,'YEAR') --------------------------------------------------------------------------- +000000000-01 -- GaussDB gaussdb=#  SET a_format_version='10c'; SET gaussdb=# SET a_format_dev_version='s2'; SET gaussdb=# SELECT NUMTOYMINTERVAL(0.01, 'YEAR') FROM DUAL; numtoyminterval ----------------- 00:00:00 (1 row) ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| SESSIONTIMEZONE | 支持，有差异      | - 赋值语法差异。GaussDB为set session time zone 8。Oracle为alter session set time_zone= '+08:00'。  - 默认值差异。GaussDB为时区名称形式如:PRC。Oracle为偏移量形式，如：+08：00。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| SYS_EXTRACT_UTC  | 支持，有差异        | 当入参时间值落在夏令时跳变间隙（DST gap）中时，Oracle数据库报错ORA-01878，GaussDB不报错，以跳变前的时区偏移量为基准计算UTC时间。例如：悉尼时区Australia/Sydney在2024-10-06 02:00:00处于夏令时开始间隙（时钟从02:00 AEST跳至03:00 AEDT），SYS_EXTRACT_UTC(TIMESTAMP '2024-10-06 02:00:00 Australia/Sydney')在Oracle数据库报错，在GaussDB返回2024-10-05 16:00:00（以跳变前偏移量UTC+10计算）。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| SYSDATE          | 支持，有差异         | 返回值类型不一致。GaussDB中关闭mapping_date_to_datea时，返回值类型为timestamp without time zone；GaussDB中开启mapping_date_to_datea时，返回值类型为datea。Oracle返回值类型为date。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| SYSTIMESTAMP     | 支持，有差异      | - GaussDB毫秒计算只支持6位，Oracle数据库支持9位。  - GaussDB中SYSTIMESTAMP在同一SQL语句内每次调用均实时获取操作系统当前时间，因此同一语句中多次调用可能返回不同的时间值。Oracle数据库中SYSTIMESTAMP在同一SQL语句内返回相同的语句级快照时间。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| TO_DSINTERVAL    | 支持，有差异      | - GaussDB不支持dsinterval类型，暂时用interval兼容dsinterval类型。  - GaussDB不支持nlsparam参数，传入nlsparam参数会报函数不存在的错误；Oracle支持nlsparam参数但该参数已无实际作用，仅为向后兼容保留。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| TO_TIMESTAMP     | 支持，有差异       | - GaussDB毫秒计算只支持6位，Oracle数据库支持9位。当格式串指定FF7\~FF9时，Oracle数据库可存储并返回对应精度的小数秒（如FF7返回7位），GaussDB的TIMESTAMP类型物理精度上限为6位，超出6位的小数秒部分直接截断（而非舍入），返回结果最多保留6位小数秒。 说明： 此截断行为与TIMESTAMP字面量的舍入规则不同，字面量场景的舍入规则参见[数据类型](https://support.huaweicloud.com/distributed-ref-v10-gaussdb/gaussdb-08-0004.html)章节。   - 对YYYY格式指定输入0000年时：GaussDB中会被修改为当前年份；Oracle中会报错。  - 对于fmt入参中包含的文本分隔符"text"时：GaussDB中不会对输入进行文本分隔符的校验；Oracle中会对输入进行文本分隔符的校验。  - GaussDB中对于fmt入参中包含DAY/DY等星期格式时，可能返回未知结果。  - GaussDB中小数部分值为0时，不显示小数位；Oracle中显示9位小数位0。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| TO_TIMESTAMP_TZ | 支持，有差异      | - GaussDB的timestamptz等价于Oracle的timestampwithlocaltimezone，缺少Oracle对应的timestamptz类型。nls_date_language只支持ENGLISH和AMERICAN两种语言。  - GaussDB底层使用IANA时区数据库（tzdata）。对于部分国家或地区时区（如PRC），在表示远早于标准时间引入日期的时间值（如1900年以前）时，IANA数据库使用LMT（Local Mean Time，本地平均时）定义该地区的本地时间偏移，而非固定的标准时区偏移。Oracle数据库对远早日期采用固定标准时区偏移，不使用LMT。因此，对于远早日期的带时区时间戳，GaussDB与Oracle的时区偏移值可能不一致。 ``` -- Oracle SQL> SELECT DBTIMEZONE AS "Database", SESSIONTIMEZONE AS "Session" FROM DUAL; Dat Session --- --------------------------------------------------------------------------- PRC PRC SQL> SELECT TO_TIMESTAMP_TZ('0001-01-01 00:00:00 +00:00', 'YYYY-MM-DD HH24:MI:SS TZH:TZM') FROM DUAL; TO_TIMESTAMP_TZ('0001-01-0100:00:00+00:00','YYYY-MM-DDHH24:MI:SSTZH:TZM') --------------------------------------------------------------------------- 0001-01-01 00:00:00.000000000 +00:00 -- GaussDB gaussdb=#  SET a_format_version='10c'; SET gaussdb=# SET a_format_dev_version='s1'; SET gaussdb=> SET TIMEZONE = 'Asia/Beijing'; SET gaussdb=> SELECT TO_TIMESTAMP_TZ('0001-01-01 00:00:00 +00:00', 'YYYY-MM-DD HH24:MI:SS TZH:TZM') FROM DUAL; to_timestamp_tz ------------------------ 0001-01-01 08:00:00+08 (1 row) gaussdb=> SET TIMEZONE = 'PRC'; SET gaussdb=# SELECT TO_TIMESTAMP_TZ('0001-01-01 00:00:00 +00:00', 'YYYY-MM-DD HH24:MI:SS TZH:TZM') FROM DUAL; to_timestamp_tz ------------------------------ 0001-01-01 08:05:43+08:05:43 (1 row) ```    |
| TO_YMINTERVAL    | 支持，有差异      | GaussDB不支持yminterval类型，暂时用interval兼容yminterval类型。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| TRUNC             | 支持，有差异       | GaussDB返回的类型与第一个入参的类型保持一致，Oracle始终返回date类型，另外支持指定的format也有区别，具体支持的列表详见[时间和日期处理函数和操作符](https://support.huaweicloud.com/distributed-ref-v10-gaussdb/gaussdb-08-0046.html)。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| TZ_OFFSET        | 支持，有差异       | - 当接收一个时区名称作为入参时，GaussDB支持的时区名称的类型少于Oracle。例如GaussDB不支持时区缩写（如PST、CST、EST等），请使用IANA时区区域名称（如US/Pacific）替代。  - 入参为时区偏移量格式（如'+hh:mi'或'-hh:mi'）时，当偏移量为零（如'-00:00'），Oracle数据库会将输出规范化为+00:00，GaussDB保留输入的原始符号，返回-00:00。  - 当入参仅包含空白字符（如空格）时，GaussDB返回空，Oracle数据库报错。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| ROUND            | 支持，有差异      | 返回值类型不一致。GaussDB中关闭mapping_date_to_datea时，返回值类型为timestamp without time zone；GaussDB中开启mapping_date_to_datea时，返回值类型为datea。Oracle返回值类型为date。 GaussDB入参可以为字符类型，而Oracle不支持字符类型作为round函数入参。 第二个入参在指定单位为由ISO 8601标准定义的包含日历周的年份，例如iyyy、iy时，Oracle和GaussDB部分年份返回结果存在差异。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
   
 表5通用比较函数 
| Oracle数据库   | GaussDB数据库 | 差异                                                                                                                                                                                                                                                             |
|:---|:---|:---|
| GREATEST | 支持，有差异    | - GaussDB不支持NLS_SORT参数指定的比较方式，只支持二进制比较。  - GaussDB不支持多语种的表达式。   |
| LEAST       | 支持，有差异    | - GaussDB不支持NLS_SORT参数指定的比较方式，只支持二进制比较。  - GaussDB不支持多语种的表达式。     |
   
 表6转换函数 
| Oracle数据库        | GaussDB数据库 | 差异                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
|:---|:---|:---|
| ASCIISTR         | 支持         | -                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| CAST              | 支持，有差异    | - GaussDB不支持multiset子句。  - GaussDB不支持nlsparam参数。    - 当进行CAST(expr AS NUMBER, fmt)操作时，GaussDB要求输入数据中的逗号个数需不小于fmt中的逗号个数，否则会进行报错；Oracle中会对fmt中多余的逗号进行忽略。 ``` -- Oracle SELECT CAST('10' AS NUMBER, '99,99,99') FROM DUAL; -- 10 -- GaussDB gaussdb=#  SET a_format_version='10c'; SET gaussdb=# SET a_format_dev_version='s1'; SET gaussdb=# SELECT CAST('10' AS NUMBER, '99,99,99') FROM DUAL; ERROR:  surplus fmt. CONTEXT:  referenced column: numeric ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| HEXTORAW        | 支持         | -                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| RAWTOHEX           | 支持，有差异     | 当函数入参为数值类型（包括整型、浮点型等）、时间类型（DATEA、TIMESATMP等）时，函数返回结果不一致。 ``` -- Oracle SQL> SELECT RAWTOHEX(1), RAWTOHEX(1.12) FROM DUAL; RAWT RAWTOH ---- ------ C102 C1020D SQL> SELECT RAWTOHEX(TO_DATE('1970-01-01', 'YYYY-MM-DD')) FROM DUAL; RAWTOHEX(TO_DATE ---------------- B207010100000000 -- GaussDB gaussdb=# SELECT RAWTOHEX(1), RAWTOHEX(1.12) FROM DUAL; rawtohex | rawtohex ----------+---------- 31       | 312e3132 (1 row) gaussdb=# SELECT RAWTOHEX(TO_DATE('1970-01-01', 'YYYY-MM-DD')) FROM DUAL; rawtohex -------------------- 30312d4a414e2d3730 (1 row) ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| TO_BINARY_DOUBLE | 支持，有差异      | - GaussDB不支持nlsparam参数。  - GaussDB中字面量输入按照IEEE 754 浮点标准解析，能正确返回目标类型范围内的值；Oracle中的数值字面量（无f/d后缀）先经过NUMBER类型中转，受到NUMBER类型范围约束（1E-130\~ 1E+126）和字符串解析长度限制，超出上限会报错，超出下限会返回0。   ``` -- Oracle SELECT TO_BINARY_DOUBLE(1e+400) FROM DUAL;   --  字面量阶段超NUMBER范围 -- numeric overflow SELECT TO_BINARY_DOUBLE(LPAD('9', 4000, '9')) FROM DUAL;   -- 字符串解析阶段超长度 invalid number SELECT TO_BINARY_DOUBLE(-2.2250738585072014E-308) FROM DUAL; -- 0 -- GaussDB gaussdb=# SET a_format_version='10c'; SET gaussdb=# SET a_format_dev_version='s2'; SET gaussdb=# SELECT TO_BINARY_DOUBLE(1e+400) FROM DUAL; to_binary_double ------------------ Infinity (1 row) gaussdb=# SELECT TO_BINARY_DOUBLE(LPAD('9', 4000, '9')) FROM DUAL; to_binary_double ------------------ Infinity (1 row) gaussdb=# SELECT TO_BINARY_DOUBLE(-2.2250738585072014E-308) FROM DUAL; to_binary_double ----------------------- -2.2250738585072e-308 (1 row) ``` - GaussDB与Oracle的fmt选项差异点描述：   1. GaussDB不支持fmt格式：C  2. GaussDB不支持fmt格式：EEEE  3. 对于fmt格式9解析非数字字符时：GaussDB会进行跳过；Oracle会报错。   - 无fmt参数时，GaussDB要求字符串严格符合浮点数字面量格式，不符合即报错；Oracle对含数值格式相关字符（如-、+）的非标准字符串，可能截断返回有效前缀而并非报错，对含非数值格式字符的字符串报错。 ``` -- Oracle SELECT TO_BINARY_DOUBLE('1-23') FROM DUAL; -- 1 -- GaussDB gaussdb=# SET a_format_version='10c'; SET gaussdb=# SET a_format_dev_version='s2'; SET gaussdb=# SELECT TO_BINARY_DOUBLE('1-23') FROM DUAL; ERROR:  invalid input syntax for type double precision: "1-23" CONTEXT:  referenced column: to_binary_double ```     - 如果入参中存在null值时：GaussDB直接返回null；Oracle中会正常执行函数功能。  - TO_BINARY_DOUBLE('NAN')返回的NAN，在与0的数值运算中，GaussDB与Oracle存在差异。 - Oracle中，NAN与0计算的结果恒为NAN。  - GaussDB中，NAN与0的计算符合0值计算的正常算术逻辑。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| TO_BINARY_FLOAT | 支持，有差异       | - GaussDB不支持nlsparam参数。  - GaussDB中，字面量输入按照IEEE 754浮点标准解析，可以正确返回目标类型范围内的值；Oracle中的数值字面量（无f/d后缀）需先经过NUMBER类型中转，受到NUMBER类型范围约束（1E-130 \~ 1E+126）和字符串解析长度限制，超出上限时会进行报错，超出下限时会返回0。 ``` -- Oracle SELECT TO_BINARY_FLOAT(1e+400) FROM DUAL;   --  字面量阶段超NUMBER范围 -- numeric overflow SELECT TO_BINARY_FLOAT(LPAD('9', 4000, '9')) FROM DUAL;   -- 字符串解析阶段超长度 -- invalid number -- GaussDB gaussdb=# SET a_format_version='10c'; SET gaussdb=# SET a_format_dev_version='s2'; SET gaussdb=# SELECT TO_BINARY_FLOAT(1e+400) FROM DUAL; to_binary_float ----------------- Infinity (1 row) gaussdb=# SELECT TO_BINARY_FLOAT(LPAD('9', 4000, '9')) FROM DUAL; to_binary_float ----------------- Infinity (1 row) ```     - GaussDB与Oracle的fmt选项差异点描述：   1. GaussDB不支持fmt格式：C  2. GaussDB不支持fmt格式：EEEE  3. 对于fmt格式9解析非数字字符时：GaussDB会进行跳过；Oracle会报错。   - 无fmt参数时，GaussDB要求字符串严格符合浮点数字面量格式，不符合即报错；Oracle对含数值格式相关字符（如-、+）的非标准字符串可能截断返回有效前缀而非报错，对含非数值格式字符的字符串报错。 ``` -- Oracle SELECT TO_BINARY_FLOAT('1-23') FROM DUAL; -- 1 -- GaussDB gaussdb=# SET a_format_version='10c'; SET gaussdb=# SET a_format_dev_version='s2'; SET gaussdb=# SELECT TO_BINARY_FLOAT('1-23') FROM DUAL; ERROR:  invalid input syntax for type real: "1-23" CONTEXT:  referenced column: to_binary_float ```     - 如果入参中存在null值时：GaussDB直接返回null；Oracle中会正常执行函数功能。  - TO_BINARY_FLOAT('NAN')返回的NAN，在与0的数值运算中，GaussDB与Oracle存在差异。 - Oracle中，NAN与0计算结果恒为NAN。  - GaussDB中，NAN与0的计算符合0值计算的正常算术逻辑。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| TO_BLOB          | 支持，有差异   | - GaussDB不支持long raw类型。  - GaussDB不支持bfile、mime_type类型。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| TO_CLOB         | 支持，有差异       | GaussDB不支持BLOB类型作为入参，Oracle支持。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| TO_DATE          | 支持，有差异    | - 不支持多语种参数。  - GaussDB不支持BLOB类型作为入参，Oracle支持。  - 返回类型不一致。GaussDB中打开mapping_date_to_datea时，返回值类型为datea；GaussDB中关闭mapping_date_to_datea时，返回值类型为timestamp。  - GaussDB中打开mapping_date_to_datea时，受控制参数nls_date_format影响；GaussDB中关闭mapping_date_to_datea时，不受控制参数nls_date_format影响。  - 部分format格式不支持。  - fmt = 'j'。1582年10月15日之前Oracle数据库与GaussDB输出不一致。  - 无分割符时，不保证与Oracle数据库完全一致。如to_date('220725', 'yymmdd')，yy/rr按照固定长度4解析，会解析为2207年25月，25非法月份则会报错。  - 如果入参中存在null值时：GaussDB直接返回null；Oracle中会正常执行函数功能。    - 部分场景下，Oracle可忽略fmt的空格，GaussDB则严格校验。因此使用时建议入参字符串与fmt严格匹配。 ``` -- Oracle SQL> SELECT TO_DATE('15-JANUARY -2024', 'DD-MONTH-YYYY') FROM DUAL; TO_DATE ------------------- 2024-01-15 00:00:00 -- GaussDB（月份JANUARY后带空格） gaussdb=# SELECT TO_DATE('15-JANUARY -2024', 'DD-MONTH-YYYY') FROM DUAL; ERROR:  Invalid data exists in a string for matching date. CONTEXT:  referenced column: to_date ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| TO_MULTI_BYTE     | 支持         | -                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| TO_NCHAR         | 支持，有差异      | - GaussDB：将入参的类型转换为text。  - Oracle：将入参的类型转换为国家字符集（national character set）。   其余差异请参见TO_CHAR函数。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| TO_NUMBER         | 支持，有差异    | GaussDB不支持NLS_PARAM参数。 GaussDB不支持CLOB类型作为入参，Oracle支持。 GaussDB与Oracle的format选项差异点描述： 1. $ GaussDB不支持该format。   2. , (comma) GaussDB：逗号可以出现在format的任意位置。 Oracle： - 在format中，逗号只能出现在整数部分，且不能出现在数字开头；在原数据中，逗号可以在数字的开头位置。  - 支持format中的逗号与原数据的逗号个数和位置不一致，但最后一个逗号的位置需一致。  - 原数据和format中的连续逗号，等同于没有逗号。  - 当原数据中没有逗号时，format的最后一个逗号后面的数字位数需与原数据相等。    3. B GaussDB未实现该功能。   4. C GaussDB不支持NLS参数。   5. G GaussDB不支持NLS参数。   6. L GaussDB不支持NLS参数。   7. U GaussDB不支持NLS参数。   8. D GaussDB不支持NLS参数。   9. PR GaussDB：等同于S，返回负数。 Oracle： - 返回\<尖括号\>中的负值。  - 返回带前导和尾随空格的正值。  - 限制：PR格式元素只能出现在数字格式模型的最后一个位置。    10. RN \| rn GaussDB未实现该功能。   11. TM\| TM9 \| TMe GaussDB未实现该功能。   12. V GaussDB未实现该功能。   13. FM - GaussDB：当有FM时，允许format中的逗号比原数据中多，不需要严格保持一致。  - Oracle：返回值保留前后的空格。    14. EEEE GaussDB未实现该功能。   15. XXXX 对于负数入参的处理，GaussDB和Oracle返回结果不一致。    |
| TO_CHAR         | 支持，有差异      | - GaussDB不支持nlsparam参数。  - fmt'5'未在Oracle数据库文档中，未进行适配。  - 对于入参为字符类型时：Oracle的返回值类型与入参类型保持一致；GaussDB则统一返回text类型的返回值。  - 入参类型为INTERVAL类型且未显式指定fmt时，GaussDB返回结果与Oracle存在格式差异。 ``` -- GaussDB gaussdb=# SELECT TO_CHAR(INTERVAL '2 12:30:45' DAY TO SECOND) FROM DUAL; to_char ------------------ 2.52135416666667 (1 row) -- Oracle SQL> SELECT TO_CHAR(INTERVAL '2 12:30:45' DAY TO SECOND) FROM DUAL; TO_CHAR(INTERVAL'21 ------------------- +02 12:30:45.000000 ```     - 对于零值占位符处理逻辑不同，Oracle中严格按格式模板保留指定位数的零；GaussDB中则固定返回一位零。 ``` -- GaussDB gaussdb=# SELECT TO_CHAR(0, '999V99') FROM DUAL; to_char --------- 0 (1 row) -- Oracle SQL> SELECT TO_CHAR(0, '999V99') FROM DUAL; TO_CHA ------ 00 ```     - 如果入参中存在null值时：GaussDB直接返回null；Oracle中会正常执行函数功能。    - GaussDB不支持fmt格式：TZH、TZM。 ``` -- GaussDB gaussdb=# set a_format_version = '10c'; SET gaussdb=# set a_format_dev_version = 's7'; SET gaussdb=# SELECT TO_CHAR(TIMESTAMP '2024-06-15 14:30:00 +08:00', 'TZH:TZM') FROM DUAL; ERROR:  invalid date format model CONTEXT:  referenced column: to_char -- Oracle SELECT TO_CHAR(TIMESTAMP '2024-06-15 14:30:00 +08:00', 'TZH:TZM') FROM DUAL; -- +08:00 ```     - 如果数值的整数部分超过fmt格式表示整数的位数，会使用#号填充整改格式宽度，GaussDB和Oracle的返回结果存在差异。 ``` -- GaussDB gaussdb=# SET a_format_version='10c'; SET gaussdb=# SET a_format_dev_version='s2'; SET gaussdb=# SELECT TO_NCHAR(1000, '99.99MI') FROM DUAL; to_nchar ---------- ##### (1 row) -- Oracle SELECT TO_CHAR(-1000, '$99.99MI') FROM DUAL; -- ####### ```     - 如果数值为0，fmt格式B与S、D、.（点）搭配使用时，GaussDB和Oracle的返回结果存在差异。 ``` -- GaussDB gaussdb=# SET a_format_version='10c'; SET gaussdb=# SET a_format_dev_version='s1'; SET gaussdb=# SELECT TO_CHAR(0, 'B9999.99S') FROM DUAL; to_char ----------- .  + (1 row) -- Oracle SELECT TO_CHAR(0, 'B9999.99S') FROM DUAL; -- 全部替换为空格 ```     - format格式中，不支持SP后缀（将数值转换为英文单词拼写），指定该后缀后不生效，数值仍以数字形式输出。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| TO_SINGLE_BYTE    | 支持          | -                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| TREAT            | 支持，有差异     | GaussDB不支持使用"."操作符取值，不支持转化为object类型。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| UNISTR            | 支持，有差异      | GaussDB只支持UTF-8编码，Oracle数据库支持UTF-8和UTF-16编码。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
   
 表7大对象函数 
| Oracle数据库    | GaussDB数据库 | 差异                               |
|:---|:---|:---|
| EMPTY_BLOB  | 支持           | -                                   |
| EMPTY_CLOB | 支持，有差异    | GaussDB的CLOB类型不支持Oracle数据库中的定位器概念。 |
   
 表8层次函数 
| Oracle数据库             | GaussDB数据库 | 差异                                                                                                                                                                                                                                                                  |
|:---|:---|:---|
| SYS_CONNECT_BY_PATH | 支持，有差异   | GaussDB中第一个入参指定的列的类型仅支持CHAR/VARCHAR/NVARCHAR2/TEXT/INT1/INT2/INT4/INT8/FLOAT4/FLOAT8/NUMERIC类型。当前该函数col输入不支持表达式输入，列内容与separator分隔符重复不支持报错。                                                                                                                            |
| CONNECT_BY_ROOT        | 支持，有差异       | 在GaussDB中，对于CONNECT_BY_ROOT运算存在以下语法限制：若其后指定的列名为非保留关键字时，则必须通过括号将列名进行包裹（如CONNECT_BY_ROOT(column_name)）才能为该表达式赋予别名，直接使用无括号形式会导致语法错误。如：CONNECT_BY_ROOT unreserved_keyword_column_name AS alias_name需要修改为CONNECT_BY_ROOT (unreserved_keyword_column_name) AS alias_name。 |
   
 表9XML类型函数 
| Oracle数据库   | GaussDB数据库 | 差异                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
|:---|:---|:---|
| EXISTSNODE | 支持，有差异       | 在入参有命名空间时，xpath和命名空间都需要定义别名。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| EXTRACTVALUE  | 支持，有差异    | 目前仅支持xpath1.0版本。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| SYS_XMLAGG   | 支持，有差异    | xmlagg的别名，可使用xmlagg代替。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| XMLAGG      | 支持，有差异    | 具体差异如说明所示。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| XMLCOMMENT   | 支持，有差异    | 具体差异如说明所示。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| XMLCONCAT   | 支持，有差异     | 具体差异如说明所示。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| XMLELEMENT   | 支持，有差异      | xmlelement和xmlattributes的name字段赋值为NULL时，行为与Oracle不一致。 - xmlelement的name字段赋值为NULL时，结果显示name信息为空，且不显示属性信息。  - xmlattributes的name字段赋值为NULL时，不显示属性信息。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| XMLEXISTS  | 支持，有差异    | GaussDB入参为xml类型。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| XMLFOREST    | 支持，有差异     | GaussDB返回值为xml类型。 GaussDB不支持EVALNAME语法。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| XMLPARSE      | 支持，有差异       | GaussDB返回值为xml类型。 GaussDB不支持WELLFORMED语法。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| XMLROOT      | 支持，有差异       | GaussDB返回值为xml类型。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| XMLSERIALIZE    | 支持，有差异        | 语法规则规则不同，GaussDB入参需要在value后加上AS type，Oracle可以省略不加。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| XMLTABLE      | 支持，有差异        | GaussDB： - 使用XPath 1.0表达式从xml中选取数据。  - 不支持声明默认命名空间。  - 不支持多组输入及取别名。  - 不支持RETURNING SEQUENCE BY REF子句和( SEQUENCE ) BY REF子句。  - XPath查询与输出功能基于libxml2库实现。该实现继承libxml2的字符处理机制，包括对XML特殊字符（如\<, \>, \&, ", '）的转义规则。  - 使用数字和xml文本组成的序列输入场景下，存在以下差异： - 不支持标准xpath和xml组合成序列输入。  - xml文本中支持携带版本信息。  - 形如'1e10'的科学计数法中，支持'e'或'E'与指数间存在空格。     Oracle：使用XQuery表达式从xml中选取数据。 |
| XMLQUERY      | 支持，有差异     | GaussDB： - 仅支持XPath1.0语法。  - 固定xml文本根节点为上下文空间开始寻找文本节点。   Oracle：使用XQuery表达式从xml中选取数据。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| XMLCAST        | 支持，有差异       | GaussDB支持的数据类型中，部分数据类型由于与Oracle数据库支持的数据类型本身存在差异，输出的数据格式以及精度上会有差异。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| GETSTRINGVAL    | 支持，有差异       | 具体差异如说明所示。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| GETCLOBVAL     | 支持，有差异        | 具体差异如说明所示。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| XMLSEQUENCE   | 支持，有差异      | 具体差异如说明所示。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
   
![](https://support.huaweicloud.com/distributed-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
- 由于[表9]中罗列的XML类型函数基于libxml2实现，因此在部分场景下与Oracle存在行为差异，主要体现在XML解析、特殊字符转义规则以及XPath查询结果格式等方面。
  以下示例展示了同一XML查询在GaussDB与Oracle中输出的差异：
  GaussDB中的ORA兼容模式下：
  ```
  gaussdb=# SELECT * FROM xmltable('/' passing xmltype('<a>&lt; &gt; &quot; &amp; &apos;</a>'));
          column_value
  ----------------------------
   <a>&lt; &gt; " &amp; '</a>+
  (1 row)
  ```
  Oracle：
  ```
  SQL> SELECT * FROM xmltable('/' passing xmltype('<a>&lt; &gt; &quot; &amp; &apos;</a>'));
  COLUMN_VALUE
  --------------------------------------------------------------------------------
  <a>&lt; &gt; &quot; &amp; &apos;</a>
  ```
  
- GaussDB所依赖的libxml2库版本升级时，可能引入不兼容变更。
 
 表10JSON函数 
| Oracle数据库 | GaussDB数据库 | 差异                                                                                                                                                                                                                                                                                                                                                                                                        |
|:---|:---|:---|
| JSON_ARRAY  | 支持，有差异   | GaussDB：入参为可变参数列表(\[VARIADIC "any"\])。 Oracle：入参更复杂，为( expr \[ FORMAT JSON \] \[, expr \[ FORMAT JSON \] \]... \[ JSON_on_null_clause \] \[ JSON_returning_clause \] \[ STRICT \] )。                                                                                                                                                                      |
| JSON_OBJECT | 支持，有差异     | GAUSSDB：支持函数JSON_OBJECT(\[key, val\[, key1, val1\] ...\])，key重复时，保留第一组key-value。 Oracle：入参更复杂，为( key_name VARCHAR2, value_expr \[, key_name VARCHAR2, value_expr \]... \[ JSON_on_null_clause \] \[ JSON_returning_clause \] \[ STRICT \] )。支持显式的键值对配对、独立的NULL值处理策略（如ABSENT ON NULL或NULL ON NULL）、返回类型控制以及严格模式（STRICT，防止键名重复或类型不匹配，未指定时如果存在重复key，默认全部保留）。 |
   
 表11编码解码函数 
| Oracle数据库 | GaussDB数据库 | 差异                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
|:---|:---|:---|
| DECODE   | 支持，有差异      | 条件表达式比较时，如果一侧为定长字符类型，另一侧为变长字符类型，GaussDB会忽略尾部空格（与比较操作符行为一致），Oracle不会忽略尾部空格。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| DUMP      | 支持，有差异     | 因存储格式不同，GaussDB中数值和时间类型的返回结果和Oracle数据库不一致。如： - GaussDB中"SELECT dump(123);"返回"Typ=23 Len=4: 123,0,0,0"（需要先执行SET a_format_version='10c';以及SET a_format_dev_version='s2';）。  - Oracle中"SELECT dump(123) FROM dual;"返回"Typ=2 Len=3: 194,2,24"。                                                                                                                                                                                            |
| ORA_HASH  | 支持，有差异    | GaussDB中有以下行为： - 时间类型的入参转换成字符串类型再进行hash。  - 不支持maxbucket参数。                                                                                                                                                                                                                                                                                                                                                                            |
| VSIZE     | 支持，有差异     | - 因存储格式不同，GaussDB中数值和时间类型的返回结果和Oracle数据库不一致。如： - GaussDB中"SELECT vsize(999);"返回4（需要先执行SET a_format_version='10c';以及SET a_format_dev_version='s2';）。  - Oracle中"SELECT vsize(999) FROM dual;"返回3。    - GaussDB不支持xmltype类型的入参。   |
   
 表12空值相关的函数 
| Oracle数据库 | GaussDB数据库 | 差异                                                                         |
|:---|:---|:---|
| COALESCE  | 支持        | -                                                                         |
| LNNVL   | 支持       | -                                                                          |
| NULLIF | 支持，有差异    | 表达式比较时，如果一侧为定长字符类型，另一侧为变长字符类型，GaussDB会忽略尾部空格（与比较操作符行为一致），Oracle不会忽略尾部空格。 |
| NVL      | 支持，有差异    | 第一个表达式为NULL时，GaussDB返回类型为text，Oracle返回第二个表达式的数据类型。                        |
| NVL2      | 支持       | -                                                                         |
   
 表13环境和标识符函数 
| Oracle数据库   | GaussDB数据库 | 差异                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
|:---|:---|:---|
| SYS_CONTEXT | 支持，有差异     | - GaussDB支持SYS_CONTEXT(namespace, attribute)，不支持通过SYS_CONTEXT(namespace, attribute, len)指定返回值的长度。  - GaussDB对不支持的参数返回NULL。 以下为不支持的参数列表： - 'action'  - 'is_application_root'  - 'is_application_pdb'  - 'audited_cursorid'  - 'authenticated_identity'  - 'authentication_data'  - 'authentication_method'  - 'cdb_domain'  - 'cdb_name'  - 'client_identifier'  - 'con_id'  - 'con_name'  - 'current_sql_length'  - 'db_domain'  - 'db_supplemental_log_level'  - 'dblink_info'  - 'drain_status'  - 'entryid'  - 'enterprise_identity'  - 'fg_job_id'  - 'global_uid'  - 'identification_type'  - 'instance'  - 'is_dg_rolling_upgrade'  - 'ldap_server_type'  - 'module'  - 'network_protocol'  - 'nls_calendar'  - 'nls_sort'  - 'nls_territory'  - 'oracle_home'  - 'os_user'  - 'platform_slash'  - 'policy_invoker'  - 'proxy_enterprise_identity'  - 'proxy_user'  - 'proxy_userid'  - 'scheduler_job'  - 'session_edition_id'  - 'session_edition_name'  - 'sessionid'  - 'statementid'  - 'terminal'  - 'unified_audit_sessionid'  - 'session_default_collation'  - 'client_info'  - 'bg_job_id'  - 'client_program_name'  - 'current_bind'  - 'global_context_memory'  - 'host'  - 'current_sqln'     |
| SYS_GUID    | 支持        | -                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| USER        | 支持，有差异     | 返回值类型不一致。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| USERENV     | 支持，有差异    | GaussDB对不支持的参数返回NULL。 以下为不支持的参数列表： - 'action'  - 'is_application_root'  - 'is_application_pdb'  - 'audited_cursorid'  - 'authenticated_identity'  - 'authentication_data'  - 'authentication_method'  - 'cdb_domain'  - 'cdb_name'  - 'client_identifier'  - 'con_id'  - 'con_name'  - 'current_sql_length'  - 'db_domain'  - 'db_supplemental_log_level'  - 'dblink_info'  - 'drain_status'  - 'entryid'  - 'enterprise_identity'  - 'fg_job_id'  - 'global_uid'  - 'identification_type'  - 'is_dg_rolling_upgrade'  - 'ldap_server_type'  - 'module'  - 'network_protocol'  - 'nls_calendar'  - 'nls_sort'  - 'nls_territory'  - 'oracle_home'  - 'os_user'  - 'platform_slash'  - 'policy_invoker'  - 'proxy_enterprise_identity'  - 'proxy_user'  - 'proxy_userid'  - 'scheduler_job'  - 'session_edition_id'  - 'session_edition_name'  - 'sessionid'  - 'statementid'  - 'terminal'  - 'unified_audit_sessionid'  - 'session_default_collation'  - 'client_info'  - 'bg_job_id'  - 'client_program_name'  - 'current_bind'  - 'global_context_memory'  - 'host'  - 'current_sqln'                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
   
