Hologres已相容的Spark函數 - Hologres

Hologres自V3.1版本起，通過增加hg_spark_funcs擴充包，支援若干Spark相容函數。本文為您介紹Hologres已相容的Spark函數及使用樣本。

函數	功能
ACOSH	計算反雙曲餘弦值。
ASINH	計算反雙曲正弦值。
ATANH	計算雙曲正切值。
BETWEEN	判斷指定值x是否在指定[min, max]範圍內。
BIN	計算二進位值。
BIT_COUNT	擷取二進位計算後的位元。
BITWISE_AND	進行按位邏輯與（AND）計算。
BITWISE_NOT	Bitwise按位邏輯非（NOT）計算。
BITWISE_OR	Bitwise按位邏輯或（OR）計算。
BITWISE_XOR	Bitwise按位邏輯異（XOR）計算。
CHECKED_ADD	加法計算。該函數在數值溢出時會報錯，而不是靜默溢出。
CHECKED_DIVIDE	除法計算。該函數在數值溢出時會報錯，而不是靜默溢出。
CHECKED_MULTIPLY	乘法計算。該函數在數值溢出時會報錯，而不是靜默溢出。
CHECKED_SUBTRACT	減法計算。該函數在數值溢出時會報錯，而不是靜默溢出。
CONTAINS	判斷參數x是否包含參數y。
CONV	將字串形式的數字從一種進位（源進位）轉換為另一種進位（目標進位）。
COSH	計算雙曲餘弦值。
CRC32	計算CRC32雜湊值。
CSC	計算餘割值。
ENDSWITH	判斷第一個輸入參數是否以第二個輸入參數結尾。
EXPM1	計算Euler數（自然對數的底）的冪次方減 1，即“exp(x) - 1”。
FIND_IN_SET	尋找指定字串在逗號分隔數組字串中的位置，並返回其從1開始的索引值。
FROM_UNIXTIME	將自UNIX紀元（1970-01-01 00:00:00 UTC）以來的秒數（BIGINT類型）轉換為指定的時間格式。
HEX	將輸入資料轉換為16進位格式。
HYPOT	計算兩個值平方和的平方根。
IN	判斷指定數值是否存在於指定的數組中。
ISNAN	判斷資料是否為NAN（Not a Number）。
LEVENSHTEIN	計算兩個字串之間的LEVENSHTEIN距離（即編輯距離），表示將一個字串轉換為另一個字串所需的最少單字元編輯操作次數。
LOG10	計算給指定值以10為底的對數。
LOG1P	計算給指定值加1後的自然對數。
LOG2	計算給指定值以2為底的對數。
MIGHT_CONTAIN	判斷指定值是否可能存在於Bloom Filter中。
MONOTONICALLY_INCREASING_ID	產生單調遞增且唯一的64位整數，但這些整數不連續。
PMOD	計算參數x除以y的正餘數。
REMAINDER	計算除法運算中的模數（即餘數）。
RINT	計算最接近的整數。
SEC	正割函數，是三角函數的一種，表示為角度的餘弦值的倒數。
SHA1	計算字串的SHA-1（Secure Hash Algorithm 1）雜湊值，並將結果轉換為十六進位字串。
SHA2	計算字串的SHA-2雜湊值（SHA-224、SHA-256、SHA-384和SHA-512），並將結果轉換為十六進位字串。
SHIFTLEFT	將目標值按位左移。
SHIFTRIGHT	將目標值按位右移。
SINH	計算雙曲正弦值
SOUNDEX	產生字串的Soundex代碼。
STARTSWITH	判斷第一個參數是否以第二個參數開始。
SUBSTRING_INDEX	擷取字串中分隔字元第n次出現之前的部分。
UNHEX	將十六進位的字串轉換為VARBIT。
URL_DECODE	取消轉義URL的編碼值。
URL_ENCODE	通過編碼進行轉義。

安裝擴充

在使用Spark函數前，需要Superuser在DB內執行以下語句安裝擴充包才可以正常使用。一個DB只需執行一次即可，如果建立新的DB，還需要再次執行如下語句。

CREATE extension hg_spark_funcs;

說明

該擴充只支援建在hg_spark_funcs Schema下，手動指定其他Schema無效。

樣本資料

本文Spark函數參數x暫不支援常量入參，下文樣本均使用該樣本資料。

CREATE TABLE public.spark_test(a INT);
INSERT INTO public.spark_test VALUES (3);

Spark函數

調用 hg_spark_funcs Schema下的函數有兩種方式，推薦使用方式一：

方式一：顯式指定Schema（推薦）
直接在函數名前使用 hg_spark_funcs. 首碼進行調用。
```
SELECT hg_spark_funcs.ACOSH(a) FROM public.spark_test;
```
方式二：設定搜尋路徑 (search_path)
先將 hg_spark_funcs 添加到當前會話的搜尋路徑中，之後便可直接調用函數，無需加首碼。
```
-- 1. 將hg_spark_funcs加入搜尋路徑
SET search_path = 'hg_spark_funcs';
-- 2. 直接調用函數
SELECT ACOSH(a) FROM public.spark_test;
```

說明

關於Spark相容函數的詳細使用方法，請參見Spark Functions。

ACOSH

描述：計算反雙曲餘弦值。
```
ACOSH(x)
```
參數說明
x：必填，支援DOUBLE PRECISION類型。
傳回值說明
返回DOUBLE PRECISION類型。

樣本

-- 方式一：直接調用 (推薦)
SELECT hg_spark_funcs.ACOSH(a) FROM public.spark_test;

-- 方式二：先設定搜尋路徑，再調用
SET search_path = 'hg_spark_funcs';
SELECT ACOSH(a) FROM public.spark_test;

返回結果如下。

acosh
------------------
1.762747174039086

ASINH

描述：計算反雙曲正弦值。
```
ASINH(x)
```
參數說明
x：必填，支援DOUBLE PRECISION類型。
傳回值說明
返回DOUBLE PRECISION類型。

樣本

-- 方式一：直接調用 (推薦)
SELECT hg_spark_funcs.ASINH(a) FROM public.spark_test;

-- 方式二：先設定搜尋路徑，再調用
SET search_path = 'hg_spark_funcs';
SELECT ASINH(a) FROM public.spark_test;

返回結果如下。

      asinh
------------------
 1.8184464592320668

ATANH

描述：計算雙曲正切值。
```
ATANH(x)
```
參數說明
x：必填，支援DOUBLE PRECISION類型。
傳回值說明
返回DOUBLE PRECISION類型。

樣本

-- 方式一：直接調用 (推薦)
SELECT hg_spark_funcs.ATANH(a) FROM public.spark_test;

-- 方式二：先設定搜尋路徑，再調用
SET search_path = 'hg_spark_funcs';
SELECT ATANH(a) FROM public.spark_test;

返回結果如下。

 atanh
-------
   NaN

BETWEEN

描述：判斷指定值x是否在指定[min， max]範圍內。
```
hg_spark_funcs.BETWEEN(x, min, max)
```
說明
由於BETWEEN為Hologres關鍵字，使用時需增加"hg_spark_funcs."首碼。
參數說明
- x：必填，支援BIGINT類型。
- min：必填，指定範圍的最小值，支援BIGINT類型。
- max：必填，指定範圍的最大值，支援BIGINT類型。
傳回值說明
返回BOOLEAN類型。若x在指定範圍內，則返回t（true）；反之，則返回f（false）。

樣本

SELECT hg_spark_funcs.BETWEEN(a,2 ,4) FROM public.spark_test;

返回結果如下。

 between
---------
 t

BIN

描述：計算二進位值。
```
BIN(x)
```
參數說明
x：必填，支援BIGINT類型。
傳回值說明
返回TEXT類型。

樣本

-- 方式一：直接調用 (推薦)
SELECT hg_spark_funcs.BIN(a) FROM public.spark_test;

-- 方式二：先設定搜尋路徑，再調用
SET search_path = 'hg_spark_funcs';
SELECT BIN(a) FROM public.spark_test;

返回結果如下。

 bin
-----
 11

BIT_COUNT

描述：擷取二進位計算後的位元。
```
BIT_COUNT(x)
```
參數說明
x：必填，支援BIGINT類型。
傳回值說明
返回INTEGER類型。

樣本

-- 方式一：直接調用 (推薦)
SELECT hg_spark_funcs.BIT_COUNT(a) FROM public.spark_test;

-- 方式二：先設定搜尋路徑，再調用
SET search_path = 'hg_spark_funcs';
SELECT BIT_COUNT(a) FROM public.spark_test;

返回結果如下。

 bit_count
-----------
         2

BITWISE_AND

描述：進行按位邏輯與（AND）計算。
```
BITWISE_AND(x, y)
```
參數說明
x和y：必填，支援INTEGER類型。
傳回值說明
返回INTEGER類型。

樣本

-- 方式一：直接調用 (推薦)
SELECT hg_spark_funcs.BITWISE_AND(a, 2) FROM public.spark_test;

-- 方式二：先設定搜尋路徑，再調用
SET search_path = 'hg_spark_funcs';
SELECT BITWISE_AND(a, 2) FROM public.spark_test;

返回結果如下。

 bitwise_and
-------------
           2

BITWISE_NOT

描述：Bitwise按位邏輯非（NOT）計算。
```
BITWISE_NOT(x)
```
參數說明
x：必填，支援BIGINT類型。
傳回值說明
返回BIGINT類型。

樣本

-- 方式一：直接調用 (推薦)
SELECT hg_spark_funcs.BITWISE_NOT(a) FROM public.spark_test;

-- 方式二：先設定搜尋路徑，再調用
SET search_path = 'hg_spark_funcs';
SELECT BITWISE_NOT(a) FROM public.spark_test;

返回結果如下。

 bitwise_not
-------------
          -4

BITWISE_OR

描述：Bitwise按位邏輯或（OR）計算。
```
BITWISE_OR(x, y)
```
參數說明
x和y：必填，支援BIGINT類型。
傳回值說明
返回BIGINT類型。

樣本

-- 方式一：直接調用 (推薦)
SELECT hg_spark_funcs.BITWISE_OR(a, 2) FROM public.spark_test;

-- 方式二：先設定搜尋路徑，再調用
SET search_path = 'hg_spark_funcs';
SELECT BITWISE_OR(a, 2) FROM public.spark_test;

返回結果如下。

 bitwise_or
------------
          3

BITWISE_XOR

描述：Bitwise按位邏輯異（XOR）計算。
```
BITWISE_XOR(x, y)
```
參數說明
x和y：必填，支援INTEGER類型。
傳回值說明
返回INTEGER類型。

樣本

-- 方式一：直接調用 (推薦)
SELECT hg_spark_funcs.BITWISE_XOR(a, 2) FROM public.spark_test;

-- 方式二：先設定搜尋路徑，再調用
SET search_path = 'hg_spark_funcs';
SELECT BITWISE_XOR(a, 2) FROM public.spark_test;

返回結果如下。

 bitwise_xor
-------------
           1

CHECKED_ADD

描述：加法計算。該函數在數值溢出時會報錯，而不是靜默溢出。
```
CHECKED_ADD(x, y)
```
參數說明
x和y：必填，支援BIGINT類型。
傳回值說明
返回BIGINT類型。

樣本

-- 方式一：直接調用 (推薦)
SELECT hg_spark_funcs.CHECKED_ADD(a, 2147483647) FROM public.spark_test;

-- 方式二：先設定搜尋路徑，再調用
SET search_path = 'hg_spark_funcs';
SELECT CHECKED_ADD(a, 2147483647) FROM public.spark_test;

返回結果如下。

--部分報錯資訊如下
ERROR:  internal error: Run func: spark_checked_add fails with Exception: VeloxUserError

CHECKED_DIVIDE

描述：除法計算。該函數在數值溢出時會報錯，而不是靜默溢出。
```
CHECKED_DIVIDE(x, y)
```
參數說明
x和y：必填，支援BIGINT類型。
傳回值說明
返回BIGINT類型。

樣本

-- 方式一：直接調用 (推薦)
SELECT hg_spark_funcs.CHECKED_DIVIDE(a, 1/2147483647) FROM public.spark_test;

-- 方式二：先設定搜尋路徑，再調用
SET search_path = 'hg_spark_funcs';
SELECT CHECKED_DIVIDE(a, 1/2147483647) FROM public.spark_test;

返回結果如下。

--部分報錯資訊如下
ERROR:  internal error: Run func: spark_checked_divide fails with Exception: VeloxUserError

CHECKED_MULTIPLY

描述：乘法計算。該函數在數值溢出時會報錯，而不是靜默溢出。
```
CHECKED_MULTIPLY(x, y)
```
參數說明
x和y：必填，支援BIGINT類型。
傳回值說明
返回BIGINT類型。

樣本

-- 方式一：直接調用 (推薦)
SELECT hg_spark_funcs.CHECKED_MULTIPLY(a, 2147483647) FROM public.spark_test;

-- 方式二：先設定搜尋路徑，再調用
SET search_path = 'hg_spark_funcs';
SELECT CHECKED_MULTIPLY(a, 2147483647) FROM public.spark_test;

返回結果如下。

--部分報錯資訊如下
ERROR:  internal error: Run func: spark_checked_multiply fails with Exception: VeloxUserError

CHECKED_SUBTRACT

描述：減法計算。該函數在數值溢出時會報錯，而不是靜默溢出。
```
CHECKED_SUBTRACT(x, y)
```
參數說明
x和y：必填，支援BIGINT類型。
傳回值說明
返回BIGINT類型。

樣本

-- 方式一：直接調用 (推薦)
SELECT hg_spark_funcs.CHECKED_SUBTRACT(a, -2147483647) FROM public.spark_test;

-- 方式二：先設定搜尋路徑，再調用
SET search_path = 'hg_spark_funcs';
SELECT CHECKED_SUBTRACT(a, -2147483647) FROM public.spark_test;

返回結果如下。

--部分報錯資訊如下
ERROR:  internal error: Run func: spark_checked_subtract fails with Exception: VeloxUserError

CONTAINS

描述：判斷參數x是否包含參數y。
```
CONTAINS(x, y)
```
參數說明
x和y：必填，支援TEXT類型。
傳回值說明
返回BOOLEAN類型，若x包含y，則返回t（true）；反之，則返回f（false）。

樣本

-- 方式一：直接調用 (推薦)
SELECT hg_spark_funcs.CONTAINS(a::text, '3') FROM public.spark_test;

-- 方式二：先設定搜尋路徑，再調用
SET search_path = 'hg_spark_funcs';
SELECT CONTAINS(a::text, '3') FROM public.spark_test;

返回結果如下。

 contains
----------
 t

CONV

描述：將字串形式的數字從一種進位（源進位）轉換為另一種進位（目標進位）。
```
CONV(x, n, m)
```
參數說明
- x：必填，字串形式的數字，支援TEXT類型。
- n：必填，源進位，支援INTEGER類型。
- m：必填，目標進位，支援INTEGER類型。
傳回值說明
返回TEXT類型。

樣本

-- 方式一：直接調用 (推薦)
SELECT hg_spark_funcs.CONV(a::text, 10, 2) FROM public.spark_test;

-- 方式二：先設定搜尋路徑，再調用
SET search_path = 'hg_spark_funcs';
SELECT CONV(a::text, 10, 2) FROM public.spark_test;

返回結果如下。

 conv
------
 11

COSH

描述：計算雙曲餘弦值。
```
COSH(x)
```
參數說明
x：必填，支援DOUBLE PRECISION類型。
傳回值說明
返回DOUBLE PRECISION類型。

樣本

-- 方式一：直接調用 (推薦)
SELECT hg_spark_funcs.COSH(a) FROM public.spark_test;

-- 方式二：先設定搜尋路徑，再調用
SET search_path = 'hg_spark_funcs';
SELECT COSH(a) FROM public.spark_test;

返回結果如下。

       cosh
------------------
 10.0676619957778

CRC32

描述：計算CRC32雜湊值。
```
CRC32(x)
```
參數說明
x：必填，支援BYTEA類型。
傳回值說明
返回BIGINT類型。

樣本

-- 方式一：直接調用 (推薦)
SELECT hg_spark_funcs.CRC32(hg_spark_funcs.bin(a)::bytea) FROM public.spark_test;

-- 方式二：先設定搜尋路徑，再調用
SET search_path = 'hg_spark_funcs';
SELECT CRC32(bin(a)::bytea) FROM public.spark_test;

返回結果如下。

   crc32
------------
 3596227959

CSC

描述：計算餘割值。
```
CSC(x)
```
參數說明
x：必填，支援DOUBLE PRECISION類型。
傳回值說明
返回DOUBLE PRECISION類型。

樣本

-- 方式一：直接調用 (推薦)
SELECT hg_spark_funcs.CSC(a) FROM public.spark_test;

-- 方式二：先設定搜尋路徑，再調用
SET search_path = 'hg_spark_funcs';
SELECT CSC(a) FROM public.spark_test;

返回結果如下。

       csc
------------------
 7.08616739573719

ENDSWITH

描述：判斷第一個輸入參數是否以第二個輸入參數結尾。
```
ENDSWITH(x, y)
```
參數說明
x和y：必填，支援TEXT類型。
傳回值說明
返回BOOLEAN類型，若參數x是以參數y結尾，則返回t（true）；反之，則返回f（false）。

樣本

-- 方式一：直接調用 (推薦)
SELECT hg_spark_funcs.ENDSWITH(concat(a, 'hologres'), 'gres') FROM public.spark_test;

-- 方式二：先設定搜尋路徑，再調用
SET search_path = 'hg_spark_funcs';
SELECT ENDSWITH(concat(a, 'hologres'), 'gres') FROM public.spark_test;

返回結果如下。

 endswith
----------
 t

EXPM1

描述：計算Euler數（自然對數的底）的冪次方減 1，即"exp(x) - 1"。
```
EXPM1(x)
```
參數說明
x：必填，支援DOUBLE PRECISION類型。
傳回值說明
返回DOUBLE PRECISION類型。

樣本

-- 方式一：直接調用 (推薦)
SELECT hg_spark_funcs.EXPM1(a) FROM public.spark_test;

-- 方式二：先設定搜尋路徑，再調用
SET search_path = 'hg_spark_funcs';
SELECT EXPM1(a) FROM public.spark_test;

返回結果如下。

      expm1
------------------
 19.0855369231877

FIND_IN_SET

描述：尋找指定字串在逗號分隔數組字串中的位置，並返回其從1開始的索引值。
```
FIND_IN_SET(x, y)
```
參數說明
x和y：必填，支援類型TEXT類型。
傳回值說明
返回INTEGER類型。若未找到指定字串，則返回0。

樣本

-- 方式一：直接調用 (推薦)
SELECT hg_spark_funcs.FIND_IN_SET(a::text, 'a,b,c,2') FROM public.spark_test;

-- 方式二：先設定搜尋路徑，再調用
SET search_path = 'hg_spark_funcs';
SELECT FIND_IN_SET(a::text, 'a,b,c,2') FROM public.spark_test;

返回結果如下。

 find_in_set
-------------
           4

FROM_UNIXTIME

描述：將自UNIX紀元（1970-01-01 00:00:00 UTC）以來的秒數（BIGINT類型）轉換為指定的時間格式。
```
FROM_UNIXTIME(x, y)
```
參數說明
- x：必填，秒數，支援BIGINT類型。
- y：必填，時間格式，支援TEXT類型。
傳回值說明
返回TEXT類型。

樣本

-- 方式一：直接調用 (推薦)
SELECT hg_spark_funcs.FROM_UNIXTIME(a, 'yyyy-MM-dd HH:mm:ss') FROM public.spark_test;

-- 方式二：先設定搜尋路徑，再調用
SET search_path = 'hg_spark_funcs';
SELECT FROM_UNIXTIME(a, 'yyyy-MM-dd HH:mm:ss') FROM public.spark_test;

返回結果如下。

    from_unixtime
---------------------
 1970-01-01 00:00:03

HEX

描述：將輸入資料轉換為16進位格式。
```
HEX(x)
```
參數說明
x：必填，秒數，支援BIGINT類型。
傳回值說明
返回TEXT類型。

樣本

-- 方式一：直接調用 (推薦)
SELECT hg_spark_funcs.HEX(a) FROM public.spark_test;

-- 方式二：先設定搜尋路徑，再調用
SET search_path = 'hg_spark_funcs';
SELECT HEX(a) FROM public.spark_test;

返回結果如下。

 hex
-----
 3

HYPOT

描述：計算兩個值平方和的平方根。
```
HYPOT(x, y)
```
參數說明
x和y：必填，支援DOUBLE PRECISION類型。
傳回值說明
返回DOUBLE PRECISION類型。

樣本

-- 方式一：直接調用 (推薦)
SELECT hg_spark_funcs.HYPOT(a, 4) FROM public.spark_test;

-- 方式二：先設定搜尋路徑，再調用
SET search_path = 'hg_spark_funcs';
SELECT HYPOT(a, 4) FROM public.spark_test;

返回結果如下。

 hypot
-------
     5

IN

描述：判斷指定數值是否存在於指定的數組中。
```
IN(x, y)
```
參數說明
- x：必填，支援BIGINT類型。
- y：必填，目標數組，支援BIGINT類型。
傳回值說明
返回BOOLEAN類型。若參數y包含指定參數x，則返回t（true）；反之，則返回f（false）。

樣本

SELECT hg_spark_funcs.IN(a, ARRAY[2,5,3]) FROM public.spark_test;

返回結果如下。

 in
----
 t

ISNAN

描述：判斷資料是否為NAN（Not a Number）。
```
ISNAN(x)
```
參數說明
x：必填，支援DOUBLE PRECISION類型。
傳回值說明
返回BOOLEAN類型。若參數x是NAN，則返回t（true）；反正，則返回f（false）。

樣本

-- 方式一：直接調用 (推薦)
SELECT hg_spark_funcs.ISNAN(a) FROM public.spark_test;

-- 方式二：先設定搜尋路徑，再調用
SET search_path = 'hg_spark_funcs';
SELECT ISNAN(a) FROM public.spark_test;

返回結果如下。

 isnan
-------
 f

LEVENSHTEIN

描述：計算兩個字串之間的LEVENSHTEIN距離（即編輯距離），表示將一個字串轉換為另一個字串所需的最少單字元編輯操作次數。
```
LEVENSHTEIN(x, y)
```
參數說明
x和y：必填，支援TEXT類型。
傳回值說明
返回INTEGER類型。

樣本

-- 方式一：直接調用 (推薦)
SELECT hg_spark_funcs.LEVENSHTEIN(a::text, 'hologres') FROM public.spark_test;

-- 方式二：先設定搜尋路徑，再調用
SET search_path = 'hg_spark_funcs';
SELECT LEVENSHTEIN(a::text, 'hologres') FROM public.spark_test;

返回結果如下。

 levenshtein
-------------
           8

LOG10

描述：計算給指定值以10為底的對數。
```
LOG10(x)
```
參數說明
x：必填，支援DOUBLE PRECISION類型。
傳回值說明
返回DOUBLE PRECISION類型。

樣本

-- 方式一：直接調用 (推薦)
SELECT hg_spark_funcs.LOG10(a) FROM public.spark_test;

-- 方式二：先設定搜尋路徑，再調用
SET search_path = 'hg_spark_funcs';
SELECT LOG10(a) FROM public.spark_test;

返回結果如下。

       log10
-------------------
 0.477121254719662

LOG1P

描述：計算給指定值加1後的自然對數。
```
LOG1P(x)
```
參數說明
x：必填，支援DOUBLE PRECISION類型。
傳回值說明
返回DOUBLE PRECISION類型。

樣本

-- 方式一：直接調用 (推薦)
SELECT hg_spark_funcs.LOG1P(a) FROM public.spark_test;

-- 方式二：先設定搜尋路徑，再調用
SET search_path = 'hg_spark_funcs';
SELECT LOG1P(a) FROM public.spark_test;

返回結果如下。

      log1p
------------------
 1.38629436111989

LOG2

描述：計算給指定值以2為底的對數。
```
LOG2(x)
```
參數說明
x：必填，支援DOUBLE PRECISION類型。
傳回值說明
返回DOUBLE PRECISION類型。

樣本

-- 方式一：直接調用 (推薦)
SELECT hg_spark_funcs.LOG2(a) FROM public.spark_test;

-- 方式二：先設定搜尋路徑，再調用
SET search_path = 'hg_spark_funcs';
SELECT LOG2(a) FROM public.spark_test;

返回結果如下。

       log2
------------------
 1.58496250072116

MIGHT_CONTAIN

描述：判斷指定值是否可能存在於Bloom Filter中。
```
MIGHT_CONTAIN(x, y)
```
參數說明
- x：必填，支援BYTEA類型。
- y：必填，支援BIGINT類型。
傳回值說明
返回BOOLEAN類型。若參數存在於Bloom Filter，則返回t（true）；反正，則返回f（false）。

樣本

-- 方式一：直接調用 (推薦)
SELECT hg_spark_funcs.MIGHT_CONTAIN(a::text::bytea, 3) FROM public.spark_test;

-- 方式二：先設定搜尋路徑，再調用
SET search_path = 'hg_spark_funcs';
SELECT MIGHT_CONTAIN(a::text::bytea, 3) FROM public.spark_test;

返回結果如下。

 might_contain
---------------
 f

MONOTONICALLY_INCREASING_ID

描述：產生單調遞增且唯一的64位整數，但這些整數不連續。
```
MONOTONICALLY_INCREASING_ID()
```
傳回值說明
返回BIGINT類型。

樣本

-- 方式一：直接調用 (推薦)
SELECT hg_spark_funcs.MONOTONICALLY_INCREASING_ID() FROM public.spark_test;

-- 方式二：先設定搜尋路徑，再調用
SET search_path = 'hg_spark_funcs';
SELECT MONOTONICALLY_INCREASING_ID() FROM public.spark_test;

返回結果如下。

 monotonically_increasing_id
-----------------------------
                           0

PMOD

描述：計算參數x除以y的正餘數。
```
PMOD(x, y)
```
參數說明
x和y：必填，支援BIGINT類型。
傳回值說明
返回BIGINT類型。

樣本

-- 方式一：直接調用 (推薦)
SELECT hg_spark_funcs.PMOD(a, 2) FROM public.spark_test;

-- 方式二：先設定搜尋路徑，再調用
SET search_path = 'hg_spark_funcs';
SELECT PMOD(a, 2) FROM public.spark_test;

返回結果如下。

 pmod
------
    1

REMAINDER

描述：計算除法運算中的模數（即餘數）。
```
REMAINDER(x, y)
```
參數說明
x和y：必填，支援BIGINT類型。
傳回值說明
返回BIGINT類型。

樣本

-- 方式一：直接調用 (推薦)
SELECT hg_spark_funcs.REMAINDER(a, 2) FROM public.spark_test;

-- 方式二：先設定搜尋路徑，再調用
SET search_path = 'hg_spark_funcs';
SELECT REMAINDER(a, 2) FROM public.spark_test;

返回結果如下。

 remainder
-----------
         1

RINT

描述：計算最接近的整數。
```
RINT(x)
```
參數說明
x：必填，支援DOUBLE PRECISION類型。
傳回值說明
返回DOUBLE PRECISION類型。

樣本

-- 方式一：直接調用 (推薦)
SELECT hg_spark_funcs.RINT(a) FROM public.spark_test;

-- 方式二：先設定搜尋路徑，再調用
SET search_path = 'hg_spark_funcs';
SELECT RINT(a) FROM public.spark_test;

返回結果如下。

 rint
------
    3

SEC

描述：正割函數，是三角函數的一種，表示為角度的餘弦值的倒數。
```
SEC(x)
```
參數說明
x：必填，支援DOUBLE PRECISION類型。
傳回值說明
返回DOUBLE PRECISION類型。

樣本

-- 方式一：直接調用 (推薦)
SELECT hg_spark_funcs.SEC(a) FROM public.spark_test;

-- 方式二：先設定搜尋路徑，再調用
SET search_path = 'hg_spark_funcs';
SELECT SEC(a) FROM public.spark_test;

返回結果如下。

        sec
-------------------
 -1.01010866590799

SHA1

描述：計算字串的SHA-1（Secure Hash Algorithm 1）雜湊值，並將結果轉換為十六進位字串。
```
SHA1(x)
```
參數說明
x：必填，支援BYTEA類型。
傳回值說明
返回TEXT類型。

樣本

-- 方式一：直接調用 (推薦)
SELECT hg_spark_funcs.SHA1(a::text::bytea) FROM public.spark_test;

-- 方式二：先設定搜尋路徑，再調用
SET search_path = 'hg_spark_funcs';
SELECT SHA1(a::text::bytea) FROM public.spark_test;

返回結果如下。

                   sha1
------------------------------------------
 77de68daecd823babbb58edb1c8e14d7106e83bb

SHA2

描述：計算字串的SHA-2雜湊值（SHA-224、SHA-256、SHA-384和SHA-512），並將結果轉換為十六進位字串。
```
SHA2(x, y)
```
參數說明
- x：必填，支援BYTEA類型。
- y：必填，支援INTEGER類型。
傳回值說明
返回TEXT類型。
說明
不支援的位長度返回NULL。

樣本

-- 方式一：直接調用 (推薦)
SELECT hg_spark_funcs.SHA2(a::text::bytea, 3) FROM public.spark_test;

-- 方式二：先設定搜尋路徑，再調用
SET search_path = 'hg_spark_funcs';
SELECT SHA2(a::text::bytea, 3) FROM public.spark_test;

返回結果如下。

sha2
------
NaN

SHIFTLEFT

描述：將目標值按位左移。
```
SHIFTLEFT(x, y)
```
參數說明
- x：必填，目標值，支援BIGINT類型。
- y：必填，將目標值按位左移的位元，支援INTEGER。
傳回值說明
返回BIGINT類型。

樣本

-- 方式一：直接調用 (推薦)
SELECT hg_spark_funcs.SHIFTLEFT(a, 1) FROM public.spark_test;

-- 方式二：先設定搜尋路徑，再調用
SET search_path = 'hg_spark_funcs';
SELECT SHIFTLEFT(a, 1) FROM public.spark_test;

返回結果如下。

 shiftleft
-----------
         6

SHIFTRIGHT

描述：將目標值按位右移。
```
SHIFTRIGHT(x, y)
```
參數說明
- x：必填，目標值，支援BIGINT類型。
- y：必填，將目標值按位右移的位元，支援INTEGER。
傳回值說明
返回BIGINT類型。

樣本

-- 方式一：直接調用 (推薦)
SELECT hg_spark_funcs.SHIFTRIGHT(a, 1) FROM public.spark_test;

-- 方式二：先設定搜尋路徑，再調用
SET search_path = 'hg_spark_funcs';
SELECT SHIFTRIGHT(a, 1) FROM public.spark_test;

返回結果如下。

 shiftright
------------
          1

SINH

描述：計算雙曲正弦值。
```
SINH(x)
```
參數說明
x：必填，支援DOUBLE PRECISION類型。
傳回值說明
返回DOUBLE PRECISION類型。

樣本

-- 方式一：直接調用 (推薦)
SELECT hg_spark_funcs.SINH(a) FROM public.spark_test;

-- 方式二：先設定搜尋路徑，再調用
SET search_path = 'hg_spark_funcs';
SELECT SINH(a) FROM public.spark_test;

返回結果如下。

       sinh
------------------
 10.0178749274099

SOUNDEX

描述：產生字串的Soundex代碼。
```
SOUNDEX(x)
```
參數說明
x：必填，支援TEXT類型。
傳回值說明
返回TEXT類型。

樣本

-- 方式一：直接調用 (推薦)
SELECT hg_spark_funcs.SOUNDEX(concat('holo', a)) FROM public.spark_test;

-- 方式二：先設定搜尋路徑，再調用
SET search_path = 'hg_spark_funcs';
SELECT SOUNDEX(concat('holo', a)) FROM public.spark_test;

返回結果如下。

 soundex
---------
 H400

STARTSWITH

描述：判斷第一個參數是否以第二個參數開始。
```
STARTSWITH(x, y)
```
參數說明
x和y：必填，支援TEXT類型。
傳回值說明
返回BOOLEAN類型。若第一個參數是以第二個參數開始，則返回t（true）；反之，則返回f（false）。

樣本

-- 方式一：直接調用 (推薦)
SELECT hg_spark_funcs.STARTSWITH(concat(a, 'hologres'), 'gres') FROM public.spark_test;

-- 方式二：先設定搜尋路徑，再調用
SET search_path = 'hg_spark_funcs';
SELECT STARTSWITH(concat(a, 'hologres'), 'gres') FROM public.spark_test;

返回結果如下。

 startswith
------------
 f

SUBSTRING_INDEX

描述：擷取字串中分隔字元第n次出現之前的部分。
```
SUBSTRING_INDEX(x, y, n)
```
參數說明
- x：必填，目標字元，支援TEXT類型。
- y：必填，分割字元，支援TEXT類型。
- n：必填，分割字元第幾次出現，支援INTEGER類型。
傳回值說明
返回TEXT類型。

樣本

-- 方式一：直接調用 (推薦)
SELECT hg_spark_funcs.SUBSTRING_INDEX(concat(a, 'hologres'), 'o', 2) FROM public.spark_test;

-- 方式二：先設定搜尋路徑，再調用
SET search_path = 'hg_spark_funcs';
SELECT SUBSTRING_INDEX(concat(a, 'hologres'), 'o', 2) FROM public.spark_test;

返回結果如下。

 substring_index
-----------------
 3hol

UNHEX

描述：將十六進位的字串轉換為VARBIT。
```
UNHEX(x)
```
參數說明
x：必填，支援TEXT類型。
傳回值說明
返回TEXT類型。

樣本

-- 方式一：直接調用 (推薦)
SELECT hg_spark_funcs.UNHEX(a::text) FROM public.spark_test;

-- 方式二：先設定搜尋路徑，再調用
SET search_path = 'hg_spark_funcs';
SELECT UNHEX(a::text) FROM public.spark_test;

返回結果如下。

 unhex
-------
 \x03

URL_DECODE

描述：取消轉義URL的編碼值。
```
URL_DECODE(x)
```
參數說明
x：必填，支援VARCHAR類型。
傳回值說明
返回VARCHAR類型。

樣本

-- 方式一：直接調用 (推薦)
SELECT hg_spark_funcs.URL_DECODE(hg_spark_funcs.URL_ENCODE(CONCAT('www.','中文',a,'.com'))) FROM public.spark_test;

-- 方式二：先設定搜尋路徑，再調用
SET search_path = 'hg_spark_funcs';
SELECT URL_DECODE(URL_ENCODE(CONCAT('www.','中文',a,'.com'))) FROM public.spark_test;

返回結果如下。

 url_decode
---------------
 www.中文3.com

URL_ENCODE

描述：通過編碼進行轉義。
```
URL_ENCODE(x)
```
參數說明
x：必填，支援VARCHAR類型。
傳回值說明
返回VARCHAR類型。

樣本

-- 方式一：直接調用 (推薦)
SELECT hg_spark_funcs.URL_ENCODE(CONCAT('www.','中文',a,'.com')) FROM public.spark_test;

-- 方式二：先設定搜尋路徑，再調用
SET search_path = 'hg_spark_funcs';
SELECT URL_ENCODE(CONCAT('www.','中文',a,'.com')) FROM public.spark_test;

返回結果如下。

        url_encode
-----------------------------
 www.%E4%B8%AD%E6%96%873.com