–odps sql
––
–author:宋文理
–create time:2023-03-08 15:23:52
––
– 差異分為三塊
– 1.運算符的差異
– 2.類型轉(zhuǎn)換的差異
– 3.內(nèi)建函數(shù)的差異

– 以下是運算符的差異：

– BITAND（&）
– 當輸入?yún)?shù)是BIGINT類型的時候，如果BITAND的計算結果是LONG_MIN(-263)，在普通模式下會返回NULL，
– 而Hive模式仍然是LONG_MIN。
select cast((3&5)as string); --返回1
– 示例如下
– 普通模式
set odps.sql.hive.compatible=false;
select cast((a & b) as string) from
values(-9223372036854775807L, -9223372036854775792L) t(a, b);
–返回NULL

– Hive兼容模式
set odps.sql.hive.compatible=true;
select cast((a & b) as string) from
values(-9223372036854775807L, -9223372036854775792L) t(a, b);

–返回-9223372036854775808
Hive
select cast((-9223372036854775807L & -9223372036854775792L) as string);
–返回-9223372036854775808
select cast((-9 & -2) as string); --返回-10
select cast((-2 & -3)as string); --返回-4
select cast((1 & 2)as string); --返回0
select cast((-2 & -3)as string); --返回-4
select cast((-2 & -3)as string); --返回-4
select cast(-2 as string);

INSERT overwrite TABLE ods_std_wxthct_tbv_trandetailcount_di partition (ds = ‘${bdp.system.bizdate}^{\prime })selectDEPTID,TRANID,ARTIID,DEALID,STKLOCID,TRANCOUNTID,PROVID,COUNTDATE,TRANDATE,CLDATE,CLOPTRID,CLCHECKOPTRIDfromod{s}_{s}t{g}_{w}xthc{t}_{t}b{v}_{t}randetailcoun{t}_{d}iawherecast(a.DEPTIDasbigint)>0andcast(a.ARTIIDasbigint)>0anda.ds{=}^{\prime }${bdp.system.bizdate}’;

– BITOR（|）
– 當輸入?yún)?shù)是BIGINT類型的時候，如果BITOR的計算結果是LONG_MIN(-263)，在普通模式下會返回NULL，
– 而Hive模式仍然是LONG_MIN。

– 示例如下。
– 普通模式
set odps.sql.hive.compatible=false;
select cast((a | b) as string) from
values(java.lang.Long.MIN_VALUE, 0L) t(a, b);
–返回NULL

select cast((a | b) as string) from
values(8,1) t(a, b); --返回9
select cast((a | b) as string) from
values(8,6) t(a, b); --返回14

select cast((a | b) as string) from
values(8,-1) t(a, b); --返回-1

– Hive兼容模式
set odps.sql.hive.compatible=true;
select cast((a | b) as string) from
values(java.lang.Long.MIN_VALUE, 0L) t(a, b);
–返回-9223372036854775808
– Hive
select cast(-9223372036854775808 as bigint) | 0;
– 返回-9223372036854775808
– BITXOR（^）
– 當輸入?yún)?shù)是BIGINT類型的時候，如果BITXOR的計算結果是LONG_MIN(-263)，在普通模式下會返回NULL，
– 而Hive模式仍然是LONG_MIN。

– 示例如下。
– 普通模式
set odps.sql.hive.compatible=false;
select cast((a ^ b) as string) from
values(java.lang.Long.MIN_VALUE, 0L) t(a, b);
–返回NULL

– Hive兼容模式
set odps.sql.hive.compatible=true;
select cast((a ^ b) as string) from
values(java.lang.Long.MIN_VALUE, 0L) t(a, b);
–返回-9223372036854775808

– Hive
select cast(-9223372036854775808 as bigint) ^ 0;
–返回-9223372036854775808
– EQ（=）
– 當輸入?yún)?shù)是DOUBLE類型的時候，普通模式下對相等的檢查更加寬松，如果兩個輸入?yún)?shù)足夠接近，就認為它們相等；
– 而Hive兼容模式對相等的檢查更加嚴格。

– 示例如下。
– 普通模式
set odps.sql.hive.compatible=false;
select a = 1.0 from values (1.000000000000001) t(a);
select 1.0=1.0000000000000000000000001;
– 結果是true，因為這兩個數(shù)足夠接近

– Hive兼容模式
set odps.sql.hive.compatible=true;
select a = 1.0 from values (1.000000000000001) t(a);
– 結果是false

– Hive
select 1.0 = 1.000000000000001 ;
– 結果是false
– NEQ（!=）
– 當輸入?yún)?shù)是DOUBLE類型的時候，普通模式下對相等的檢查更加寬松，如果兩個輸入?yún)?shù)足夠接近，就認為它們相等；
– 而Hive兼容模式對相等的檢查更加嚴格。

– 示例如下。
– 普通模式
set odps.sql.hive.compatible=false;
select a != 1.0 from values (1.000000000000001) t(a);
– 結果是false，因為這兩個數(shù)足夠接近

– Hive兼容模式
set odps.sql.hive.compatible=true;
select a != 1.0 from values (1.000000000000001) t(a);
– 結果是true
– Hive
select 1.000000000000001 != 1.0 ;
– 結果是true
– GE（>=）
– 當輸入?yún)?shù)是DOUBLE類型的時候，普通模式下對相等的檢查更加寬松，如果兩個輸入?yún)?shù)足夠接近，
– 就認為它們相等這會導致即使第1個輸入?yún)?shù)小于第2個參數(shù)，但是只要他們足夠接近，GE的返回結果也可能是true。

– 示例如下。
– 普通模式
set odps.sql.hive.compatible=false;
select 1.0 >= a from values (1.000000000000001) t(a);
– 結果是true，因為這兩個數(shù)足夠接近，認為它們相等

– Hive兼容模式
set odps.sql.hive.compatible=true;
select 1.0 >= a from values (1.000000000000001) t(a);
– 結果是false
– Hive
select 1.0 >= 1.000000000000001;
– 結果是false

– GT（>）
– 當輸入?yún)?shù)是DOUBLE類型的時候，普通模式下對相等的檢查更加寬松，如果兩個輸入?yún)?shù)足夠接近，
– 就認為它們相等這會導致即使第1個輸入?yún)?shù)大于第2個參數(shù)，但是只要他們足夠接近，GT的返回結果也可能是false。

– 示例如下。
– 普通模式
set odps.sql.hive.compatible=false;
select a > 1.0 from values (1.000000000000001) t(a);
– 結果是false，因為這兩個數(shù)足夠接近，認為它們相等

– Hive兼容模式
set odps.sql.hive.compatible=true;
select a > 1.0 from values (1.000000000000001) t(a);
– 結果是true
– Hive
select 1.000000000000001>1.0;
– 結果是true

– LE（<=）
– 當輸入?yún)?shù)是DOUBLE類型的時候，普通模式下對相等的檢查更加寬松，如果兩個輸入?yún)?shù)足夠接近，
– 就認為它們相等這會導致即使第1個輸入?yún)?shù)大于第2個參數(shù)，但是只要他們足夠接近，LE的返回結果也可能是true。

– 示例如下。
– 普通模式
set odps.sql.hive.compatible=false;
select a <= 1.0 from values (1.000000000000001) t(a);
– 結果是true，因為這兩個數(shù)足夠接近，認為它們相等

– Hive兼容模式
set odps.sql.hive.compatible=true;
select a <= 1.0 from values (1.000000000000001) t(a);
– 結果是false
– Hive
select 1.000000000000001 <= 1.0 ;
– 結果是false
– LT（<）
– 當輸入?yún)?shù)是DOUBLE類型的時候，普通模式下對相等的檢查更加寬松，如果兩個輸入?yún)?shù)足夠接近，
– 就認為它們相等這會導致即使第1個輸入?yún)?shù)小于第2個參數(shù)，但是只要他們足夠接近，LE的返回結果也可能是false。

– 示例如下。
– 普通模式
set odps.sql.hive.compatible=false;
select 1.0 < a from values (1.000000000000001) t(a);
– 結果是false，因為這兩個數(shù)足夠接近，認為它們相等

– Hive兼容模式
set odps.sql.hive.compatible=true;
select 1.0 < a from values (1.000000000000001) t(a);
– 結果是true
– Hive
select 1.0 < 1.000000000000001;
– 結果是true
– PLUS（+）
– 計算結果超范圍時的處理不同，在普通模式時可能會報錯，在Hive兼容模式計算結果溢出不會報錯，
– 同時為兩種模式開啟嚴格模式（odps.function.strictmode=true）。

– 示例如下。
– 普通模式
set odps.sql.hive.compatible=false;
set odps.function.strictmode=true;
select (100L + a) from values (9223372036854775807L) t(a);
– 報錯，計算結果溢出

– Hive兼容模式
set odps.sql.hive.compatible=true;
set odps.function.strictmode=true;
select (100L + a) from values (9223372036854775807L) t(a);
– 計算結果溢出，但是不會報錯
– Hive
select (100L + 9223372036854775807L) ;
– 返回-9223372036854775709，計算結果溢出，但是不會報錯

– MINUS（-）
– 計算結果超范圍時的處理不同，在普通模式時可能會報錯，在Hive兼容模式計算結果溢出不會報錯，
– 同時為兩種模式開啟嚴格模式（odps.function.strictmode=true）。

– 示例如下。
– 普通模式
set odps.sql.hive.compatible=false;
set odps.function.strictmode=true;
select (-100L - a) from values (9223372036854775807L) t(a);
– 報錯，計算結果溢出

– Hive兼容模式
set odps.sql.hive.compatible=true;
set odps.function.strictmode=true;
select (-100L - a) from values (9223372036854775807L) t(a);
– 計算結果溢出，但是不會報錯
– Hive
select (-100L - 9223372036854775807L) ;
– 返回 9223372036854775709
– MPL（*）
– 計算結果超范圍時的處理不同，在普通模式時可能會報錯，在Hive兼容模式計算結果溢出不會報錯，
– 同時為兩種模式開啟嚴格模式（odps.function.strictmode=true）。

– 示例如下。
– 普通模式
set odps.sql.hive.compatible=false;
set odps.function.strictmode=true;
select (a * 9223372036854775807L) from values (9223372036854775807L) t(a);
– 報錯，計算結果溢出

– Hive兼容模式
set odps.sql.hive.compatible=true;
set odps.function.strictmode=true;
select (a * 9223372036854775807L) from values (9223372036854775807L) t(a);
– 計算結果溢出，但是不會報錯
– Hive
select (9223372036854775807L * 9223372036854775807L) ;
– 返回1；計算結果溢出，但是不會報錯
– – DIV（/）
– 計算結果超范圍時的處理不同，在普通模式時可能會報錯，在Hive兼容模式計算結果溢出不會報錯，
– 同時為兩種模式開啟嚴格模式（odps.function.strictmode=true）。

– 示例如下。
– 普通模式
set odps.sql.hive.compatible=false;
set odps.function.strictmode=true;

select 1 / a from values (0L) t(a);
– strict模式下報錯

select 1.0 / a from values (0.0) t(a);
– strict模式下報錯

select 1BD / a from values (0BD) t(a);
– strict模式下報錯

– Hive兼容模式
set odps.sql.hive.compatible=true;
set odps.function.strictmode=true;

select 1 / a from values (0L) t(a);
– 返回NULL

select 1.0 / a from values (0.0) t(a);
– 返回NULL

select 1BD / a from values (0BD) t(a);
– 返回NULL
Hive
select 1 / 0L;
– 返回NULL

select 1.0 / 0.0;
– 返回NULL

select 1BD / 0BD;
– 返回NULL

– 以下是類型轉(zhuǎn)換的差異

– TOBIGINT
– 當輸入?yún)?shù)不合法時，普通模式下可能會報錯，Hive兼容模式返回NULL，
– 同時為兩種模式開啟即嚴格模式（odps.function.strictmode=true）。

– 示例如下。
– 普通模式
set odps.sql.hive.compatible=false;
set odps.function.strictmode=true;
select cast(a as bigint) from values (‘hello’) t(a);
– 報錯，輸入?yún)?shù)不合法

– Hive兼容模式
set odps.sql.hive.compatible=true;
set odps.function.strictmode=true;
select cast(a as bigint) from values (‘hello’) t(a);
– 返回NULL
– Hive
select cast(‘hello’ as bigint) ;
– 返回NULL
– TODECIMAL
– 當輸入?yún)?shù)不合法時，普通模式下可能會報錯，Hive兼容模式返回NULL，
– 同時為兩種模式開啟即嚴格模式（odps.function.strictmode=true）。

– 示例如下。
– 普通模式
set odps.sql.hive.compatible=false;
set odps.function.strictmode=true;
select cast(a as decimal) from values (‘hello’) t(a);
– 報錯，輸入?yún)?shù)不合法

– Hive兼容模式
set odps.sql.hive.compatible=true;
set odps.sql.udf.strict.mode=true;
select cast(a as decimal) from values (‘hello’) t(a);
– 返回NULL
– Hive
select cast(‘hello’ as decimal) ;
– 返回NULL
– TODOUBLE
– 當輸入?yún)?shù)不合法時，普通模式下可能會報錯，Hive兼容模式返回NULL，
– 同時為兩種模式開啟即嚴格模式（odps.function.strictmode=true）。

– 示例如下。
– 普通模式
set odps.sql.hive.compatible=false;
set odps.function.strictmode=true;
select cast(a as double) from values (‘hello’) t(a);
– 報錯，輸入?yún)?shù)不合法

– Hive兼容模式
set odps.sql.hive.compatible=true;
set odps.function.strictmode=true;
select cast(a as double) from values (‘hello’) t(a);
– 返回NULL
– Hive
select cast(‘hello’ as double) ;
– 返回NULL
– TOSMALLINT
– 當輸入?yún)?shù)不合法或超出范圍時，普通模式下可能會報錯，Hive兼容模式返回NULL，
– 同時為兩種模式開啟即嚴格模式（odps.function.strictmode=true）。

– 示例如下。
– 普通模式
set odps.sql.hive.compatible=false;
set odps.function.strictmode=true;
set odps.sql.type.system.odps2=true;

select cast(a as smallint) from values (‘hello’) t(a);
– 報錯，輸入?yún)?shù)不合法

select cast(a as smallint) from values (9223372036854775807L) t(a);
– 報錯，數(shù)據(jù)溢出

– Hive兼容模式
set odps.sql.hive.compatible=true;
set odps.function.strictmode=true;
set odps.sql.type.system.odps2=true;

select cast(a as smallint) from values (‘hello’) t(a);
– 返回NULL

select cast(a as smallint) from values (9223372036854775807L) t(a);
– 數(shù)據(jù)溢出但是不報錯

Hive
select cast(‘hello’ as smallint);
– 返回NULL

select cast(9223372036854775807L as smallint);
– 返回-1，數(shù)據(jù)溢出但是不報錯

– TOTINYINT
– 當輸入?yún)?shù)不合法或超出范圍時，普通模式下可能會報錯，Hive兼容模式返回NULL，
– 同時為兩種模式開啟即嚴格模式（odps.function.strictmode=true）。

– 示例如下。
– 普通模式
set odps.sql.hive.compatible=false;
set odps.function.strictmode=true;
set odps.sql.type.system.odps2=true;

select cast(a as tinyint) from values (‘hello’) t(a);
– 報錯，輸入?yún)?shù)不合法

select cast(a as tinyint) from values (9223372036854775807L) t(a);
– 報錯，數(shù)據(jù)溢出

– Hive兼容模式
set odps.sql.hive.compatible=true;
set odps.function.strictmode=true;
set odps.sql.type.system.odps2=true;

select cast(a as tinyint) from values (‘hello’) t(a);
– 返回NULL

select cast(a as tinyint) from values (9223372036854775807L) t(a);
– 數(shù)據(jù)溢出但是不報錯
– Hive
select cast(‘hello’ as tinyint) ;
– 返回NULL

select cast(9223372036854775807L as tinyint) ;
– 返回-1，數(shù)據(jù)溢出但是不報錯

– 以下是內(nèi)建函數(shù)的差異:

ACOS
– 取值超出范圍[-1,1]時，普通模式和Hive模式的表現(xiàn)不同。普通模式返回NULL，并且可能會報錯；而Hive模式返回NAN。

– 示例如下。
– 普通模式
set odps.sql.hive.compatible=false;
select acos(a) from values(1.5) t(a);
–返回NULL，并且有可能會報錯

– Hive兼容模式
set odps.sql.hive.compatible=true;
select acos(a) from values(1.5) t(a);
–返回NAN
– Hive
select acos(1.5);
–返回NAN

ASCII
– 普通模式ASCII函數(shù)返回值類型為BIGINT，Hive兼容模式ASCII函數(shù)返回值類型為INT。

– 示例如下。
– 普通模式
set odps.sql.hive.compatible=false;
explain select ascii(‘a(chǎn)bcde’);
–顯示返回值類型是bigint

– Hive兼容模式
set odps.sql.hive.compatible=true;
explain select ascii(‘a(chǎn)bcde’);
–顯示返回值類型是int
– Hive
explain select ascii(‘a(chǎn)bcde’);
–顯示返回值類型是int

ASIN
– 取值超出范圍[-1,1]時，普通模式和Hive模式的表現(xiàn)不同。普通模式返回NULL，并且可能會報錯；而Hive模式返回NAN。

– 示例如下。
– 普通模式
set odps.sql.hive.compatible=false;
select asin(a) from values(1.5) t(a);
–返回NULL，并且有可能會報錯

– Hive兼容模式
set odps.sql.hive.compatible=true;
select asin(a) from values(1.5) t(a);
–返回NAN
– Hive
select asin(a) from values(1.5) t(a);
–返回NAN

CEIL
– 普通模式CEIL函數(shù)輸入?yún)?shù)類型是DECIMAL的時候，返回值類型為BIGINT；
– Hive兼容模式CEIL函數(shù)輸入?yún)?shù)類型是DECIMAL的時候，返回值類型為DECIMAL。

– 示例如下。
– 普通模式
set odps.sql.hive.compatible=false;
explain select ceil(1.2BD);
–顯示返回值類型是bigint

– Hive兼容模式
set odps.sql.hive.compatible=true;
explain select ceil(1.2BD);
–顯示返回值類型是decimal
– Hive
explain select ceil(1.2BD);
–顯示返回值類型是decimal(2,0)
– CHR
– 輸入?yún)?shù)取值超出范圍，普通模式與Hive模式的返回結果不同。
– 普通模式會報錯，而Hive兼容模式返回空字符串。

– 示例如下。
– 普通模式
set odps.sql.hive.compatible=false;
select chr(-100L);
–報錯，輸入?yún)?shù)不合法
– Hive兼容模式
set odps.sql.hive.compatible=true;
select chr(-100L);
–返回空字符串
– Hive
select chr(-100L);
–返回空字符串

CONCAT_WS
– 輸入?yún)?shù)中有NULL，普通模式與Hive模式的返回結果不同。普通模式返回NULL，而Hive兼容模式會忽略輸入?yún)?shù)中的NULL。
– 輸入?yún)?shù)中有空數(shù)組，如下所示。普通模式下會返回NULL，而Hive兼容模式下會返回空字符串。
– string concat_ws(string , array arr)
– 示例如下。
– 普通模式
set odps.sql.hive.compatible=false;
select concat_ws(‘,’, ‘a(chǎn)’, null, ‘b’);
– 返回NULL
select concat_ws(‘,’, array());
– 返回NULL

– Hive兼容模式
set odps.sql.hive.compatible=true;
select concat_ws(‘,’, ‘a(chǎn)’, null, ‘b’);
– 返回如下值：
±----+
| _c0 |
±----+
| a,b |
±----+

select concat_ws(‘,’, array());
–返回空字符串
– Hive
select concat_ws(‘,’, ‘a(chǎn)’, null, ‘b’);
– 返回如下值：
±----+
| _c0 |
±----+
| a,b |
±----+

select concat_ws(‘,’, array());
–返回空字符串
COT
– 當輸入?yún)?shù)為0（或者是其他導致計算結果為無窮大的數(shù)）時，普通模式下會返回NULL，
– 并且可能會報錯；而Hive兼容模式返回INF。

– 示例如下。
– 普通模式
set odps.sql.hive.compatible=false;
select cot(a) from values(0.0) t(a);
–返回NULL，并且有可能會報錯

– Hive兼容模式
set odps.sql.hive.compatible=true;
select cot(a) from values(0.0) t(a);
–返回INF
– Hive不支持此函數(shù)。

EXP
– 當使用EXP函數(shù)計算的結果超出輸出類型的值域范圍時，同時為兩種模式開啟嚴格模式（odps.function.strictmode=true），
– 在普通模式下可能會報錯，而Hive兼容模式返回INF。

– 示例如下。
– 普通模式
set odps.sql.hive.compatible=false;
set odps.function.strictmode=true;
select exp(a) from values (1000L) t(a);
– 報錯 Data overflow

– Hive兼容模式
set odps.sql.hive.compatible=true;
set odps.function.strictmode=true;
select exp(a) from values (1000L) t(a);
– 返回INF
– Hive
select exp(1000L) ;
– 返回INF

FIND_IN_SET
– 普通模式FIND_IN_SET函數(shù)返回值類型為BIGINT，Hive兼容模式FIND_IN_SET函數(shù)返回值類型為INT。

– 示例如下。
– 普通模式
set odps.sql.hive.compatible=false;
explain select find_in_set(‘a(chǎn)b’, ‘a(chǎn)bc,hello,ab,c’);
–顯示返回值類型是bigint

– Hive兼容模式
set odps.sql.hive.compatible=true;
explain select find_in_set(‘a(chǎn)b’, ‘a(chǎn)bc,hello,ab,c’);
–顯示返回值類型是int
– Hive
explain select find_in_set(‘a(chǎn)b’, ‘a(chǎn)bc,hello,ab,c’);
–顯示返回值類型是int

FLOOR
– 普通模式FLOOR函數(shù)輸入?yún)?shù)類型是DECIMAL的時候，返回值類型為BIGINT；
– Hive兼容模式FLOOR函數(shù)輸入?yún)?shù)類型是DECIMAL的時候，返回值類型為DECIMAL。

– 示例如下。
– 普通模式
set odps.sql.hive.compatible=false;
explain select floor(1.2BD);
–顯示返回值類型是bigint

– Hive兼容模式
set odps.sql.hive.compatible=true;
explain select floor(1.2BD);
–顯示返回值類型是decimal
– Hive
explain select floor(1.2BD);
–顯示返回值類型是decimal(2,0)

FROM_UNIXTIME
– 普通模式支持如下形式的function signature，不支持指定時間的格式。
– DATETIME FROM_UNIXTIME(BIGINT time)
– Hive兼容模式支持如下兩種形式的function signature，這兩種function sigature都返回STRING類型。
– 第1個signature允許指定輸出的時間格式，輸出的時間格式受SimpleDateFormat的控制，詳情請參見SimpleDateFormat。
– STRING FROM_UNIXTIME(BIGINT time, STRING format)

– STRING FROM_UNIXTIME(BIGINT time)
– 示例如下。
– 普通模式
set odps.sql.hive.compatible=false;

select from_unixtime(12345678, ‘yyyy-MM-dd HH:mm:ss’);
–報錯，from_unixtime只允許1個輸入?yún)?shù)，不允許2個輸入?yún)?shù)

select weekday(from_unixtime(0));
– 執(zhí)行成功，from_unixtime返回datetime類型，weekday接受datetime類型的輸入?yún)?shù)

– Hive兼容模式
set odps.sql.hive.compatible=true;

select from_unixtime(12345678, ‘yyyy-MM-dd HH:mm:ss’);
–返回結果如下：
±----+
| _c0 |
±----+
| 1970-05-24 05:21:18 |
±----+

select weekday(from_unixtime(0));
– 執(zhí)行失敗，因為from_unixtime返回string類型，而weekday不接受string類型輸入?yún)?shù)。
Hive
select from_unixtime(12345678, ‘yyyy-MM-dd HH:mm:ss’);
–返回結果如下：
±----+
| _c0 |
±----+
| 1970-05-24 05:21:18 |
±----+

select weekday(from_unixtime(0));
– hive不支持weekday函數(shù)

FROM_UTC_TIMESTAMP
– 當輸入?yún)?shù)超范圍時，且同時為兩種模式開啟嚴格模式（odps.function.strictmode=true），
– 普通模式返回可能會報錯，Hive兼容模式返回NULL。

– 示例如下。
– 普通模式
set odps.sql.hive.compatible=false;
set odps.function.strictmode=true;
select from_utc_timestamp(1501557840000000, ‘UTC’);
– 報錯，輸入?yún)?shù)超出范圍

– Hive兼容模式
set odps.sql.hive.compatible=true;
set odps.function.strictmode=true;
select from_utc_timestamp(1501557840000000, ‘UTC’);
– 返回NULL
– Hive
select from_utc_timestamp(1501557840000000, ‘UTC’);
– 報錯，FAILED: IllegalArgumentException Timestamp format must be yyyy-mm-dd hh:mm:ss[.fffffffff]

– HASH
– 普通模式下HASH函數(shù)返回BIGINT類型，Hive兼容模式HASH函數(shù)下返回INT類型。

– 示例如下。
– 普通模式
set odps.sql.hive.compatible=false;
explain select hash(0, 2, 4);
–返回值類型是bigint

– Hive兼容模式
set odps.sql.hive.compatible=true;
explain select hash(0, 2, 4);
–返回值類型是int
– Hive
explain select hash(0, 2, 4);
–返回值類型是int

IS_ENCODING
– 判斷輸入的字符串是否可以從指定的一個字符集from_encoding轉(zhuǎn)為另一個字符集to_encoding。也可以用于判斷輸入是否為亂碼，
– 通常您可以將from_encoding設為UTF-8，to_encoding設為GBK。
– 普通模式下，輸入字符串必須要能夠用from_encoding解碼成功，并能按照to_encoding編碼，結果才能返回false。
– Hive兼容模式下，輸入字符串必須是UTF-8編碼，并且需要能同時被from_encoding和to_encoding編碼，結果才返回false。
– 示例如下。
– 普通模式
set odps.sql.hive.compatible=false;
select is_encoding(‘中文’, ‘gbk’, ‘utf-8’);
– 返回false，'中文’是utf-8編碼，不能用gbk解碼，所以返回false

– Hive兼容模式
set odps.sql.hive.compatible=true;
select is_encoding(‘中文’, ‘gbk’, ‘utf-8’);
– 返回true，'中文’既可以轉(zhuǎn)換成gbk編碼，又可以轉(zhuǎn)換成utf-8編碼
– Hive不支持此語法。

INSTR
– 輸入?yún)?shù)為兩個字符串時，普通模式下返回值類型為BIGINT，Hive兼容模式下返回值類型為INT。

– 示例如下。
– 普通模式
set odps.sql.hive.compatible=false;
explain select instr(‘Tech on the net’, ‘e’);
–返回bigint類型

– Hive兼容模式
set odps.sql.hive.compatible=true;
explain select instr(‘Tech on the net’, ‘e’);
–返回int類型
– Hive
explain select instr(‘Tech on the net’, ‘e’);
–返回的是int類型

LENGTH
– 普通模式下使用LENGTH函數(shù)返回值類型為BIGINT，Hive兼容模式下使用LENGTH函數(shù)返回值類型為INT。

– 示例如下。
– 普通模式
set odps.sql.hive.compatible=false;
explain select length(‘hello’);
–返回bigint類型
– Hive兼容模式
set odps.sql.hive.compatible=true;
explain select length(‘hello’);
–返回int類型
– Hive
explain select length(‘hello’);
–返回int類型

LENGTHB
– 普通模式下使用LENGTHB函數(shù)返回值類型為BIGINT，Hive兼容模式下使用LENGTHB函數(shù)返回值類型為INT。

– 示例如下。
– 普通模式
set odps.sql.hive.compatible=false;
explain select lengthb(‘hello’);
–返回bigint類型

– Hive兼容模式
set odps.sql.hive.compatible=true;
explain select lengthb(‘hello’);
–返回int類型
– Hive不支持該函數(shù)。

LN
– 當輸入?yún)?shù)超范圍時，同時為兩種模式開啟嚴格模式（odps.function.strictmode=true），
– 在普通模式下可能會報錯，在Hive兼容模式下會返回NULL。

– 示例如下。
– 普通模式
set odps.sql.hive.compatible=false;
set odps.function.strictmode=true;
select ln(a) from values(-1.0) t(a);
– 報錯，輸入?yún)?shù)超出范圍

– Hive兼容模式
set odps.sql.hive.compatible=true;
set odps.function.strictmode=true;
select ln(a) from values(-1.0) t(a);
– 返回NULL
– Hive
select ln(-1.0) ;
– 返回NULL

LOCATE
– 普通模式下使用LOCATE函數(shù)返回值類型為BIGINT，Hive兼容模式下使用LOCATE函數(shù)返回值類型為INT。

– 示例如下。
– 普通模式
set odps.sql.hive.compatible=false;
explain select locate(‘a(chǎn)b’, ‘a(chǎn)bchelloabc’);
–返回bigint類型

– Hive兼容模式
set odps.sql.hive.compatible=true;
explain select locate(‘a(chǎn)b’, ‘a(chǎn)bchelloabc’);
–返回int類型
– Hive
explain select locate(‘a(chǎn)b’, ‘a(chǎn)bchelloabc’);
–返回的int類型
LOG
– 當輸入?yún)?shù)超范圍時，同時為兩種模式開啟嚴格模式（odps.function.strictmode=true），
– 在普通模式下可能會報錯，在Hive兼容模式下會返回NULL。

– 示例如下。
– 普通模式
set odps.sql.hive.compatible=false;
set oodps.function.strictmode=true;
select log(a, 10) from values(-3.0) t(a);
– 報錯，輸入?yún)?shù)超出范圍

– Hive兼容模式
set odps.sql.hive.compatible=true;
set odps.function.strictmode=true;
select log(a, 10) from values(-3.0) t(a);
– 返回NULL
– Hive
select log(-3.0, 10) ;
– 返回NULL

MOD
– 當輸入?yún)?shù)不合法時，同時為兩種模式開啟嚴格模式（odps.function.strictmode=true），
– 在普通模式下可能會報錯，在Hive兼容模式下會返回NULL。

– 示例如下。
– 普通模式
set odps.sql.hive.compatible=false;
set odps.function.strictmode=true;
select 1L % a from values(0L) t(a);
– 報錯，數(shù)據(jù)溢出

– Hive兼容模式
set odps.sql.hive.compatible=true;
set odps.function.strictmode=true;
select 1L % a from values(0L) t(a);
– 返回NULL
– Hive
select 1L % 0L;
– 返回NULL

PMOD
– 當輸入?yún)?shù)不合法時，同時為兩種模式開啟嚴格模式（odps.function.strictmode=true），
– 在普通模式下可能會報錯，在Hive兼容模式下會返回NULL。

– 示例如下。
– 普通模式
set odps.sql.hive.compatible=false;
set odps.function.strictmode=true;
select pmod(1L, a) from values(0L) t(a);
– 報錯，數(shù)據(jù)溢出

– Hive兼容模式
set odps.sql.hive.compatible=true;
set odps.function.strictmode=true;
select pmod(1L, a) from values(0L) t(a);
– 返回NULL

– Hive
select pmod(1L, 0L) ;
– 返回NULL
– POW
– 當計算結果溢出時，同時為兩種模式開啟嚴格模式（odps.function.strictmode=true），
– 在普通模式下可能會報錯，在Hive兼容模式下會返回INF。

– 示例如下。
– 普通模式
– set odps.sql.hive.compatible=false;
set odps.sql.udf.strict.mode=true;
select pow(a, 1000L) from values(1000L) t(a);
– 報錯，數(shù)據(jù)溢出

– Hive兼容模式
set odps.sql.hive.compatible=true;
set odps.sql.udf.strict.mode=true;
select pow(a, 1000L) from values(1000L) t(a);
– 返回INF
– Hive
select pow(1000L, 1000L) ;
– 返回INF

REPEAT
– 當REPEAT的個數(shù)小于零時，在普通模式下會報錯，在Hive兼容模式下會返回空字符串。

– 示例如下。
– 普通模式
set odps.sql.hive.compatible=false;
select repeat(‘hi’, n) from values (-1L) t(n);
–報錯，輸入?yún)?shù)超出范圍

– Hive兼容模式
set odps.sql.hive.compatible=true;
select repeat(‘hi’, n) from values (-1L) t(n);
– --返回空字符串
– Hive不支持該函數(shù)。

REVERSE
– 當輸入?yún)?shù)中包含中文字符時，在普通模式下按照字節(jié)來進行reverse操作，返回值可能有亂碼；
– 在Hive兼容模式下按照utf8來處理，不會出現(xiàn)亂碼。

– 示例如下。
– 普通模式
set odps.sql.hive.compatible=false;
select reverse(a) from values (‘hello中國world’) t(a);
–返回結果中有亂碼

– Hive兼容模式
set odps.sql.hive.compatible=true;
select reverse(a) from values (‘hello中國world’) t(a);
–返回結果中沒有亂碼
– Hive
select reverse(‘hello中國world’) ;
–返回dlrow國中olleh

ROUND
– 在普通模式下使用ROUND函數(shù)，本質(zhì)上只支持DOUBLE或DECIMAL兩種輸入數(shù)據(jù)類型，其他數(shù)據(jù)類型會轉(zhuǎn)換為這兩種類型；
– 在Hive兼容模式下，支持：DOUBLE、DECIMAL、BIGINT、INT、SMALLINT、TINYINT等數(shù)據(jù)類型。

– 示例如下。
– 普通模式
set odps.sql.hive.compatible=false;
explain select round(a) from values(2L) t(a);
–從執(zhí)行計劃看，輸入數(shù)據(jù)從bigint類型轉(zhuǎn)換成double類型，計算結果是double類型

– Hive兼容模式
set odps.sql.hive.compatible=true;
explain select round(a) from values(2L) t(a);
–從執(zhí)行計劃看，輸入bigint類型，輸出是bigint類型
– Hive
explain select round(2L) ;
–從執(zhí)行計劃看，輸入bigint類型，輸出是bigint類型

SIGN
– 輸入?yún)?shù)數(shù)據(jù)類型為DECIMAL時，普通模式下返回BIGINT類型，Hive兼容模式下返回INT類型。
– 輸入?yún)?shù)數(shù)據(jù)類型為DOUBLE時，普通模式下如果輸入?yún)?shù)的絕對值和0非常接近，則返回值為0。
– 示例如下。
– 普通模式
set odps.sql.hive.compatible=false;

explain select sign(a) from values(2BD) t(a);
–從執(zhí)行計劃看，返回bigint類型

select sign(a) from values (0.000000000000009) t(a);
–返回值是0.0，因為輸入?yún)?shù)和0非常緊急
– Hive兼容模式
set odps.sql.hive.compatible=true;

explain select sign(a) from values(2BD) t(a);
–從執(zhí)行計劃看，返回int類型

select sign(a) from values (0.000000000000009) t(a);
– 返回值是1.0
– Hive
explain select sign(2BD);
–從執(zhí)行計劃看，返回int類型

select sign(0.000000000000009) ;
–返回值是1

SIZE
– 普通模式下使用SIZE函數(shù)返回值類型為BIGINT，Hive兼容模式下使用SIZE函數(shù)返回值類型為INT。
– 輸入?yún)?shù)為NULL時，普通模式下返回NULL，Hive兼容模式返回-1。
– 示例如下。
– 普通模式
set odps.sql.hive.compatible=false;
explain select size(array(‘a(chǎn)’,‘b’));
–從執(zhí)行計劃看，返回bigint類型

select size(a) from values (cast(NULL as array)) t(a);
–返回結果是NULL

– Hive兼容模式
set odps.sql.hive.compatible=true;
explain select size(array(‘a(chǎn)’,‘b’));
–從執(zhí)行計劃看，返回int類型

select size(a) from values (cast(NULL as array)) t(a);
–返回結果是-1
– Hive
explain select size(array(‘a(chǎn)’,‘b’));
–從執(zhí)行計劃看，返回int類型

SPLIT
– 當輸入?yún)?shù)的分隔符為空字符串時，普通模式下返回空數(shù)組，Hive兼容模式下按照UTF-8格式分割輸入字符串。

– 示例如下。
– 普通模式
set odps.sql.hive.compatible=false;
select split(a, ‘’) from values (‘hello中國world’) t(a);
–返回空array

– Hive兼容模式
set odps.sql.hive.compatible=true;
select split(a, ‘’) from values (‘hello中國world’) t(a);
–返回[, h, e, l, l, o, 中, 國, w, o, r, l, d, ]
– Hive
select split(‘hello中國world’, ‘’) ;
–返回[“h”,“e”,“l(fā)”,“l(fā)”,“o”,“中”,“國”,“w”,“o”,“r”,“l(fā)”,“d”,“”]
SQRT
– 當輸入?yún)?shù)小于0時，同時為兩種模式開啟嚴格模式（odps.function.strictmode=true），
– 在普通模式下可能會報錯，在Hive兼容模式下會返回NULL。

– 示例如下。
– 普通模式
set odps.sql.hive.compatible=false;
set odps.function.strictmode=true;
select sqrt(a) from values (-100.0) t(a);
– 報錯，輸入?yún)?shù)小于0

– Hive兼容模式
set odps.sql.hive.compatible=true;
set odps.function.strictmode=true;
select sqrt(a) from values (-100.0) t(a);
– 返回NULL
Hive
select sqrt(-100.0);
– 返回NULL

SUBSTR
– 當輸入?yún)?shù)中的起始位置為0時，普通模式下返回空字符串，Hive兼容模式下與起始位置為1時相同。

– 示例如下。
– 普通模式
set odps.sql.hive.compatible=false;
set odps.function.strictmode=true;
select substr(a, 0) from values (‘hello, world’) t(a);
– 返回空字符串

– Hive兼容模式
set odps.sql.hive.compatible=true;
set odps.function.strictmode=true;
select substr(a, 0) from values (‘hello, world’) t(a);
– 返回如下結果：
±----+
| _c0 |
±----+
| hello, world |
±----+
Hive
select substr(‘hello, world’, 0);
– 返回如下結果：
±----+
| _c0 |
±----+
| hello, world |
±----+

UNIX_TIMESTAMP
– 普通模式下不支持兩個輸入?yún)?shù)類型為STRING，會報錯；Hive兼容模式下支持兩個STRING類型的輸入?yún)?shù)，
– 如下所示，返回值為BIGINT類型，通過format指定時間格式，時間格式請參見SimpleDateFormat。
– bigint FROM_UNIXTIME(string timeString, String format)
– 示例如下。
– 普通模式
set odps.sql.hive.compatible=false;
set odps.function.strictmode=true;
select unix_timestamp(a) from values (‘99999-01-01 00:00:00’);
– 報錯，輸入?yún)?shù)不合法

– Hive兼容模式
set odps.sql.hive.compatible=true;
set odps.function.strictmode=true;
select unix_timestamp(a) from values (‘99999-01-01 00:00:00’);
– 返回NULL
– Hive
select unix_timestamp(‘2022/7/8’, ‘yyyy/mm/dd’);
–返回結果如下：
±-----------+
| _c0 |
±-----------+
| 1641571620 |
±-----------+
select unix_timestamp(‘99999-01-01 00:00:00’) ;
–返回：3093496416000
select unix_timestamp(‘99999-01-01 00:00:00’);
–返回：3093496416000

URL_DECODE
– 當輸入?yún)?shù)不合法時，且同時為兩種模式開啟嚴格模式（odps.function.strictmode=true），
– 普通模式返回可能會報錯，Hive兼容模式返回NULL。

– 示例如下。
– 普通模式
set odps.sql.hive.compatible=false;
set odps.function.strictmode=true;

select url_decode(a) from values (‘%2’) t(a);
– 報錯，輸入?yún)?shù)不合法

– Hive兼容模式
set odps.sql.hive.compatible=true;
set odps.function.strictmode=true;

select url_decode(a) from values (‘%2’) t(a);
– 返回NULL

– Hive不支持該函數(shù)。
URL_ENCODE
– 當輸入?yún)?shù)不合法或者轉(zhuǎn)換失敗時，且同時為兩種模式開啟嚴格模式（odps.function.strictmode=true），
– 普通模式返回可能會報錯，Hive兼容模式返回NULL。

– 示例如下。
– 普通模式
set odps.sql.hive.compatible=false;
set odps.function.strictmode=true;

select url_encode(a, ‘a(chǎn)scii’) from values (‘示例’) t(a);
– 報錯，輸入?yún)?shù)不合法

– Hive兼容模式
set odps.sql.hive.compatible=true;
set odps.function.strictmode=true;

select url_encode(a, ‘a(chǎn)scii’) from values (‘示例’) t(a);
– 返回NULL
– Hive不支持該函數(shù)。