Amazon Redshift 將不再支援從修補程式 198 開始建立新的 Python UDFs。現有 Python UDF 將繼續正常運作至 2026 年 6 月 30 日。如需詳細資訊，請參閱[部落格文章](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/)。
本文為英文版的機器翻譯版本，如內容有任何歧義或不一致之處，概以英文版為準。
# 運算子和函數
透過 Amazon Redshift，您可以使用運算子和函式，對使用 SUPER 資料的大型資料集執行進階分析。SUPER 資料的運算子和函式為 SQL 建構模組，可對儲存在 Amazon Redshift 資料表中的半結構化資料進行複雜分析和操作。
下列各節將涵蓋在 Amazon Redshift 中使用 SUPER 資料的運算子和函式的語法、範例和最佳實務，以充分發揮半結構化資料的完整潛力。
## 算術運算子
SUPER 值支援使用動態類型的所有基本算術運算子 \$1、-、\$1、/、％。運算的結果類型會保持為 SUPER。對於所有運算子，除了二元運算子 \$1 之外，輸入運算元必須是數字。否則，Amazon Redshift 傳回 null。當 Amazon Redshift 執行這些運算子且動態類型不會變更時，將保留小數和浮點值之間的差異。但是，當您使用乘法和除法時，小數位數會發生變化。算術溢位仍然會導致查詢錯誤，它們不會變更為 null。如果輸入是數字，則二元運算子 \$1 執行加法；如果輸入是字串，則執行串連。如果一個運算元是一個字串，而另一個運算元是一個數字，則結果為 null。如果 SUPER 值不是數字，一元前綴運算子 \$1 和 - 將傳回 null，如以下範例所示：
```
SELECT (c_orders[0]. o_orderkey + 0.5) * c_orders[0]. o_orderkey / 10 AS math FROM customer_orders_lineitem;
math
----------------------------
1757958232200.1500
(1 row)
```
動態類型允許 SUPER 中的小數值具有不同的小數位數。Amazon Redshift 會將十進位值視為不同的靜態類型，並允許所有數學運算。Amazon Redshift 會根據運算元的比例，動態計算結果小數位數。如果其中一個運算元是浮點數，則 Amazon Redshift 會將另一個運算元提升為浮點數並產生浮點數結果。
## 算術函數
Amazon Redshift 支援 SUPER 欄的以下算術函數。如果輸入不是數字，以下項目會傳回 null：
+ FLOOR。如需詳細資訊，請參閱[FLOOR 函數](r_FLOOR.md)。
+ CEIL 和 CEILING。如需詳細資訊，請參閱[CEILING (或 CEIL) 函數](r_CEILING_FLOOR.md)。
+ ROUND。如需詳細資訊，請參閱[ROUND 函數](r_ROUND.md)。
+ TRUNC。如需詳細資訊，請參閱[TRUNC 函數](r_TRUNC.md)。
+ ABS。如需詳細資訊，請參閱[ABS 函數](r_ABS.md)。
下列範例會使用算術函數來查詢資料：
```
SELECT x, FLOOR(x), CEIL(x), ROUND(x)
FROM (
SELECT (c_orders[0]. o_orderkey + 0.5) * c_orders[0].o_orderkey / 10 AS x
FROM customer_orders_lineitem
);
x | floor | ceil | round
--------------------+---------------+---------------+---------------
1389636795898.0500 | 1389636795898 | 1389636795899 | 1389636795898
```
ABS 函數會保留輸入小數的小數位數，而 FLOOR、CEIL。ROUND 會消除輸入小數的小數位數。
## 陣列函數
Amazon Redshift 支援下列陣列合成和公用程式函式：
+ ARRAY。如需詳細資訊，請參閱[ARRAY 函數](r_array.md)。
+ ARRAY\$1CONCAT。如需詳細資訊，請參閱[ARRAY\$1CONCAT 函數](r_array_concat.md)。
+ ARRAY\$1CONTAINS。如需詳細資訊，請參閱[ARRAY\$1CONTAINS 函數](array_contains.md)。
+ ARRAY\$1DISTINCT。如需詳細資訊，請參閱[ARRAY\$1DISTINCT 函數](array_distinct.md)。
+ ARRAY\$1EXCEPT。如需詳細資訊，請參閱[ARRAY\$1EXCEPT 函數](array_except.md)。
+ ARRAY\$1FLATTEN。如需詳細資訊，請參閱[ARRAY\$1FLATTEN 函數](array_flatten.md)。
+ ARRAY\$1INTERSECTION。如需詳細資訊，請參閱[ARRAY\$1INTERSECTION 函數](array_intersection.md)。
+ ARRAY\$1POSITION。如需詳細資訊，請參閱[ARRAY\$1POSITION 函數](array_position.md)。
+ ARRAY\$1POSITIONS。如需詳細資訊，請參閱[ARRAY\$1POSITIONS 函數](array_positions.md)。
+ ARRAY\$1SORT。如需詳細資訊，請參閱[ARRAY\$1SORT 函數](array_sort.md)。
+ ARRAY\$1UNION。如需詳細資訊，請參閱[ARRAY\$1UNION 函數](array_union.md)。
+ ARRAYS\$1OVERLAP。如需詳細資訊，請參閱[ARRAYS\$1OVERLAP 函數](arrays_overlap.md)。
+ GET\$1ARRAY\$1LENGTH。如需詳細資訊，請參閱[GET\$1ARRAY\$1LENGTH 函數](get_array_length.md)。
+ SPLIT\$1TO\$1ARRAY。如需詳細資訊，請參閱[SPLIT\$1TO\$1ARRAY 函數](split_to_array.md)。
+ SUBARRAY。如需詳細資訊，請參閱[SUBARRAY 函數](r_subarray.md)。
您可以使用 ARRAY 函數 (包括其他 SUPER 值)，從 Amazon Redshift 資料類型中的值建構 SUPER 陣列。以下範例使用可變參數函數 ARRAY：
```
SELECT ARRAY(1, c.c_custkey, NULL, c.c_name, 'abc') FROM customer_orders_lineitem c;
array
-------------------------------------------------------
[1,8401,null,""Customer#000008401"",""abc""]
[1,9452,null,""Customer#000009452"",""abc""]
[1,9451,null,""Customer#000009451"",""abc""]
[1,8251,null,""Customer#000008251"",""abc""]
[1,5851,null,""Customer#000005851"",""abc""]
(5 rows)
```
下列範例使用 ARRAY\$1CONCAT 函數進行陣列串連：
```
SELECT ARRAY_CONCAT(JSON_PARSE('[10001,10002]'),JSON_PARSE('[10003,10004]'));
array_concat
------------------------------------
[10001,10002,10003,10004]
(1 row)
```
下列範例使用 SUBARRAY 函數進行陣列操作，該函數會傳回輸入陣列的子集。
```
SELECT SUBARRAY(ARRAY('a', 'b', 'c', 'd', 'e', 'f'), 2, 3);
subarray
---------------
["c","d","e"]
(1 row))
```
下列範例使用 ARRAY\$1FLATTEN 將多個層級的陣列合併為一個陣列：
```
SELECT x, ARRAY_FLATTEN(x) FROM (SELECT ARRAY(1, ARRAY(2, ARRAY(3, ARRAY()))) AS x);
x | array_flatten
----------------+---------------
[1,[2,[3,[]]]] | [1,2,3]
(1 row)
```
陣列函數 ARRAY\$1CONCAT 和 ARRAY\$1FLATTEN 使用動態類型規則。如果輸入不是陣列，它們會傳回 null 而不是錯誤。GET\$1ARRAY\$1LENGTH 函數傳回給定的物件或陣列路徑的 SUPER 陣列的長度。
```
SELECT c_name
FROM customer_orders_lineitem
WHERE GET_ARRAY_LENGTH(c_orders) = (
SELECT MAX(GET_ARRAY_LENGTH(c_orders))
FROM customer_orders_lineitem
);
```
下列範例使用 SPLIT\$1TO\$1ARRAY 將字串分割為字串陣列。該函數使用分隔符號做為選用參數。如果沒有分隔符號，則預設為逗號。
```
SELECT SPLIT_TO_ARRAY('12|345|6789', '|');
split_to_array
---------------------
["12","345","6789"]
(1 row)
```
## 定序行為
您可以使用 SUPER 透過 [CREATE TABLE](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_TABLE_NEW.html) 設定欄的定序、採用透過 [CREATE DATABASE](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_DATABASE.html) 設定的預設定序，以及透過 [COLLATE 函式](https://docs.aws.amazon.com/redshift/latest/dg/r_COLLATE.html)設定表達式的定序。
定序設定會套用至儲存在 SUPER 中的所有比較運算子和字串值，無論其為字串值、SUPER 陣列內的字串，還是 SUPER 物件的值。SUPER 物件的定序行為僅會套用至值，不會套用至屬性。例如，具有不區分大小寫定序 `{"attribute": "a"} = {"attribute": "A"}` 的值比較結果會傳回 true，而 `{"attribute": "a"} = {"ATTRIBUTE": "a"}` 會傳回 false。
## 資訊函式
SUPER 資料欄支援傳回動態類型和 SUPER 值的其他類型資訊的檢查函數。最常見的範例是 JSON\$1TYPEOF 純量函數，此函數會根據 SUPER 值的動態類型，傳回含有布林值、數字、字串、物件、陣列或 null 的 VARCHAR。Amazon Redshift 支援 SUPER 資料欄的下列布林函數：
+ [IS\$1ARRAY 函數](r_is_array.md)
+ [IS\$1BIGINT 函數](r_is_bigint.md)
+ [IS\$1CHAR 函數](r_is_char.md)
+ [IS\$1DECIMAL 函數](r_is_decimal.md)
+ [IS\$1FLOAT 函數](r_is_float.md)
+ [IS\$1INTEGER 函數](r_is_integer.md)
+ [IS\$1OBJECT 函數](r_is_object.md)
+ [IS\$1SCALAR 函數](r_is_scalar.md)
+ [IS\$1SMALLINT 函數](r_is_smallint.md)
+ [IS\$1VARCHAR 函數](r_is_varchar.md)
如需 SUPER 類型資訊函式的詳細資訊，請參閱 [SUPER 類型資訊函數](c_Type_Info_Functions.md)。
## 物件函數
以下是 Amazon Redshift 支援在 SUPER 類型物件上建立和操作的 SQL 物件函數：
+ [GET\$1NUMBER\$1ATTRIBUTES 函數](get_number_attributes.md)
+ [LOWER\$1ATTRIBUTE\$1NAMES 函式](r_lower_attribute_names.md)
+ [OBJECT 函數](r_object_function.md)
+ [OBJECT\$1TRANSFORM 函數](r_object_transform_function.md)
+ [UPPER\$1ATTRIBUTE\$1NAMES 函式](r_upper_attribute_names.md)
如需物件函數的詳細資訊，請參閱 [物件函數](Object_Functions.md)。
## 字串函數
若要在 SUPER 資料類型中使用字串常值的字串函數，您必須先將字串常值轉換為字串類型，才能套用函數。如果輸入不是字串常值，函數會傳回 null。
[字串函數](String_functions_header.md) 現在支援最多 16，000，000 個位元組。
下列範例使用 SUBSTRING 擷取大小為 5，000，000 個位元組的字串預覽，存放在 SUPER JSON 物件中
```
CREATE TABLE customer_data (
customer_id INT,
profile SUPER
);
INSERT INTO customer_data VALUES (
1,
JSON_PARSE('{"name": "John Doe", "description": "' || REPEAT('A', 5000000) || '"}')
);
SELECT
customer_id,
profile.name::VARCHAR AS name,
SUBSTRING(profile.description::VARCHAR, 1, 50) AS description_preview
FROM customer_data;
customer_id | name | description_preview
-------------+----------+----------------------------------------------------
1 | John Doe | AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
```
下列範例示範 SUPER 陣列中字串常值的 LEFT、RIGHT 和 CONCAT 函數：
```
CREATE TABLE documents (
doc_id INT,
chapters SUPER
);
INSERT INTO documents VALUES (
1,
JSON_PARSE('["' || REPEAT('hello', 400000) || '", "' || REPEAT('world', 600000) || '"]')
);
SELECT
doc_id,
LEFT(chapters[0]::VARCHAR, 20) AS chapter1_start,
RIGHT(chapters[1]::VARCHAR, 20) AS chapter2_end,
LEN(CONCAT(chapters[0]::VARCHAR, chapters[1]::VARCHAR)) AS concat_size
FROM documents;
doc_id | chapter1_start | chapter2_end | concat_size
--------+----------------------+----------------------+-------------
1 | hellohellohellohello | worldworldworldworld | 5000000
```
下列範例會將獨立字串存放在 SUPER 中：
```
CREATE TABLE text_storage (
text_id INT,
content SUPER
);
INSERT INTO text_storage VALUES
(1, REPEAT('A', 8000000)),
(2, REPEAT('B', 16000000));
SELECT
text_id,
LEN(content::VARCHAR) AS content_length
FROM text_storage;
text_id | content_length
---------+----------------
1 | 8000000
2 | 16000000
```