从补丁 198 开始，Amazon Redshift 将不再支持创建新的 Python UDF。现有的 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/)。

# 对象函数
<a name="Object_Functions"></a>

以下是 SQL 对象函数，Amazon Redshift 支持这些函数以创建 SUPER 类型对象并对这些对象执行操作：

**Topics**
+ [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)

# GET\$1NUMBER\$1ATTRIBUTES 函数
<a name="get_number_attributes"></a>

返回有关字典对象的根层存在多少个键值对的计数。

## 语法
<a name="get_number_attributes-syntax"></a>

```
GET_NUMBER_ATTRIBUTES( super_expression )
```

## 参数
<a name="get_number_attributes-arguments"></a>

 *super\$1expression*   
字典形式的 SUPER 表达式。

## 返回类型
<a name="get_number_attributes-return-type"></a>

GET\$1NUMBER\$1ATTRIBUTES 函数返回 INT 类型。

## 注意
<a name="get_number_attributes-note"></a>

此函数仅计算直接属性的数量，而不包括嵌套字典中的对。

## 示例
<a name="get_number_attributes-example"></a>

以下示例显示 GET\$1NUMBER\$1ATTRIBUTES 函数。

```
SELECT GET_NUMBER_ATTRIBUTES(JSON_PARSE('{"a": 1, "b": 2, "c": 3}'));
 get_number_attributes
-----------------------
            3
(1 row)
```

GET\$1NUMBER\$1ATTRIBUTES 函数仅在字典的第一层起作用。

```
SELECT GET_NUMBER_ATTRIBUTES(JSON_PARSE('{"a": 1, "b": {"c": 3}}'));
 get_number_attributes
-----------------------
            2
(1 row)
```

# LOWER\$1ATTRIBUTE\$1NAMES 函数
<a name="r_lower_attribute_names"></a>

使用与 [LOWER 函数](r_LOWER.md)相同的大小写转换例程，将 SUPER 值中的所有适用属性名称转换为小写。LOWER\$1ATTRIBUTE\$1NAMES 支持 UTF-8 多字节字符，每个字符最多可以有 4 个字节。

 要将 SUPER 属性名称转换为大写，请使用 [UPPER\$1ATTRIBUTE\$1NAMES 函数](r_upper_attribute_names.md)。

## 语法
<a name="r_lower_attribute_names-synopsis"></a>

```
LOWER_ATTRIBUTE_NAMES( super_expression )
```

## 参数
<a name="r_lower_attribute_names-arguments"></a>

*super\$1expression*  
SUPER 表达式。

## 返回类型
<a name="r_lower_attribute_names-return-type"></a>

`SUPER`

## 使用说明
<a name="r_lower_attribute_names-usage-notes"></a>

在 Amazon Redshift 中，列标识符传统上不区分大小写且转换为小写。如果您从区分大小写的数据格式（例如 JSON）中提取数据，则数据可能包含大小写混合的属性名称。

考虑以下示例。

```
CREATE TABLE t1 (s) AS SELECT JSON_PARSE('{"AttributeName": "Value"}');


SELECT s.AttributeName FROM t1;  

attributename
-------------
NULL


SELECT s."AttributeName" FROM t1;

attributename
-------------
NULL
```

Amazon Redshift 对这两个查询都返回 NULL。要查询 `AttributeName`，请使用 LOWER\$1ATTRIBUTE\$1NAMES 将数据的属性名称转换为小写。考虑以下示例。

```
CREATE TABLE t2 (s) AS SELECT LOWER_ATTRIBUTE_NAMES(s) FROM t1;


SELECT s.attributename FROM t2;

attributename
-------------
"Value"


SELECT s.AttributeName FROM t2; 

attributename
-------------
"Value"


SELECT s."attributename" FROM t2;

attributename
-------------
"Value"


SELECT s."AttributeName" FROM t2;

attributename
-------------
"Value"
```

用于处理大小写混合的对象属性名称的一个相关选项是 `enable_case_sensitive_super_attribute` 配置选项，它让 Amazon Redshift 可以识别 SUPER 属性名称中的大小写。这可能是使用 LOWER\$1ATTRIBUTE\$1NAMES 的替代解决方案。有关 `enable_case_sensitive_super_attribute` 的更多信息，请转至 [enable\$1case\$1sensitive\$1super\$1attribute](r_enable_case_sensitive_super_attribute.md)。

## 示例
<a name="r_lower_attribute_names_examples"></a>

**将 SUPER 属性名称转换为小写**  
以下示例使用 LOWER\$1ATTRIBUTE\$1NAMES 来转换表中所有 SUPER 值的属性名称。

```
-- Create a table and insert several SUPER values.
CREATE TABLE t (i INT, s SUPER);

INSERT INTO t VALUES
  (1, NULL), 
  (2, 'A'::SUPER),
  (3, JSON_PARSE('{"AttributeName": "B"}')),
  (4, JSON_PARSE(
     '[{"Subobject": {"C": "C"},
        "Subarray": [{"D": "D"}, "E"]
      }]'));

-- Convert all attribute names to lowercase.
UPDATE t SET s = LOWER_ATTRIBUTE_NAMES(s);

SELECT i, s FROM t ORDER BY i;

 i |                        s
---+--------------------------------------------------
 1 | NULL
 2 | "A"
 3 | {"attributename":"B"}
 4 | [{"subobject":{"c":"C"},"subarray":[{"d":"D"}, "E"]}]
```

观察 LOWER\$1ATTRIBUTE\$1NAMES 的工作原理。
+  NULL 值和标量 SUPER 值（例如 `"A"`）保持不变。
+  在 SUPER 对象中，所有属性名称都更改为小写，但诸如 `"B"` 之类的属性值保持不变。
+  LOWER\$1ATTRIBUTE\$1NAMES 以递归方式应用于嵌套在 SUPER 数组或其它对象内的任何 SUPER 对象。

**在具有重复属性名称的 SUPER 对象上使用 LOWER\$1ATTRIBUTE\$1NAMES**  
如果 SUPER 对象包含的属性的名称仅在大小写上有所不同，则 LOWER\$1ATTRIBUTE\$1NAMES 将引发错误。考虑以下示例。

```
SELECT LOWER_ATTRIBUTE_NAMES(JSON_PARSE('{"A": "A", "a": "a"}'));      

error:   Invalid input
code:    8001
context: SUPER value has duplicate attributes after case conversion.
```

# OBJECT 函数
<a name="r_object_function"></a>

创建 SUPER 数据类型的对象。

## 语法
<a name="r_object_function-synopsis"></a>

```
OBJECT ( [ key1, value1 ], [ key2, value2 ...] )
```

## 参数
<a name="r_object_function-arguments"></a>

*key1, key2*  
计算结果为 VARCHAR 类型字符串的表达式。

*value1, value2*  
除日期时间类型以外的任何 Amazon Redshift 数据类型的表达式，因为 Amazon Redshift 不会将日期时间类型强制转换为 SUPER 数据类型。有关日期时间类型的更多信息，请参阅[日期时间类型](r_Datetime_types.md)。  
对象中的 `value` 表达式无需为同一数据类型。

## 返回类型
<a name="r_object_function-returns"></a>

`SUPER`

## 示例
<a name="r_object_function_example"></a>

```
-- Creates an empty object.
select object();

object
--------
{}
(1 row)
            
-- Creates objects with different keys and values.
select object('a', 1, 'b', true, 'c', 3.14);

object
---------------------------
{"a":1,"b":true,"c":3.14}
(1 row)
               
select object('a', object('aa', 1), 'b', array(2,3), 'c', json_parse('{}'));
               
object
---------------------------------
{"a":{"aa":1},"b":[2,3],"c":{}}
(1 row)
            
-- Creates objects using columns from a table.
create table bar (k varchar, v super);
insert into bar values ('k1', json_parse('[1]')), ('k2', json_parse('{}'));
select object(k, v) from bar;

object
------------
{"k1":[1]}
{"k2":{}}
(2 rows)
            
-- Errors out because DATE type values can't be converted to SUPER type.
select object('k', '2008-12-31'::date);

ERROR:  OBJECT could not convert type date to super
```

# OBJECT\$1TRANSFORM 函数
<a name="r_object_transform_function"></a>

转换 SUPER 对象。

## 语法
<a name="r_object_transform_function-synopsis"></a>

```
OBJECT_TRANSFORM(
  input
  [KEEP path1, ...]
  [SET
    path1, value1,
    ...,  ...
  ]
)
```

## 参数
<a name="r_object_transform_function-arguments"></a>

* 输入*：  
解析为 SUPER 类型对象的表达式。

*KEEP*  
此子句中指定的所有*路径*值都将保留并传递到输出对象。  
此子句是可选的。

*path1*、*path2*...  
常量字符串文本，格式为双引号路径组成部分，以句点分隔。例如，`'"a"."b"."c"'` 是一个有效的路径值。这适用于 KEEP 和 SET 子句中的路径参数。

*SET*  
*路径*和*值*对，可修改现有路径或添加新路径，并在输出对象中设置该路径的值。  
此子句是可选的。

*value1*、*value2*...  
解析为 SUPER 类型值的表达式。请注意，数值、文本和布尔类型可解析为 SUPER。

## 返回类型
<a name="r_object_transform_function-returns"></a>

`SUPER`

## 使用说明
<a name="r_object_transform_function-usage-notes"></a>

OBJECT\$1TRANSFORM 返回一个 SUPER 类型对象，其中包含在 KEEP 中指定的*输入*路径值以及在 SET 中指定的*路径*和*值*对。

如果 KEEP 和 SET 都为空，则 OBJECT\$1TRANSFORM 返回*输入*。

如果*输入*不是 SUPER 类型*对象*，则无论 KEEP 或 SET 值如何，OBJECT\$1TRANSFORM 都会返回*输入*。

## 示例
<a name="r_object_transform_function-example"></a>

以下示例将一个 SUPER 对象转换为另一个 SUPER 对象。

```
CREATE TABLE employees (
    col_person SUPER
);

INSERT INTO employees
VALUES
    (
        json_parse('
            {
                "name": {
                    "first": "John",
                    "last": "Doe"
                },
                "age": 25,
                "ssn": "111-22-3333",
                "company": "Company Inc.",
                "country": "U.S."
            }
        ')
    ),
    (
        json_parse('
            {
                "name": {
                    "first": "Jane",
                    "last": "Appleseed"
                },
                "age": 34,
                "ssn": "444-55-7777",
                "company": "Organization Org.",
                "country": "Ukraine"
            }
        ')
    )
;

SELECT
    OBJECT_TRANSFORM(
        col_person
        KEEP
            '"name"."first"',
            '"age"',
            '"company"',
            '"country"'
        SET
            '"name"."first"', UPPER(col_person.name.first::TEXT),
            '"age"', col_person.age + 5,
            '"company"', 'Amazon'
    ) AS col_person_transformed
FROM employees;
    
--This result is formatted for ease of reading.
                  col_person_transformed
-------------------------------------------------------------
{
    "name": {
        "first": "JOHN"
    },
    "age": 30,
    "company": "Amazon",
    "country": "U.S."
}
{
    "name": {
        "first": "JANE"
    },
    "age": 39,
    "company": "Amazon",
    "country": "Ukraine"
}
```

# UPPER\$1ATTRIBUTE\$1NAMES 函数
<a name="r_upper_attribute_names"></a>

使用与 [UPPER 函数](r_UPPER.md)相同的大小写转换例程，将 SUPER 值中的所有适用属性名称转换为大写。UPPER\$1ATTRIBUTE\$1NAMES 支持 UTF-8 多字节字符，每个字符最多可以有 4 个字节。

 要将 SUPER 属性名称转换为小写，请使用 [LOWER\$1ATTRIBUTE\$1NAMES 函数](r_lower_attribute_names.md)。

## 语法
<a name="r_upper_attribute_names-synopsis"></a>

```
UPPER_ATTRIBUTE_NAMES( super_expression )
```

## 参数
<a name="r_upper_attribute_names-arguments"></a>

*super\$1expression*  
SUPER 表达式。

## 返回类型
<a name="r_upper_attribute_names-return-type"></a>

`SUPER`

## 示例
<a name="r_upper_attribute_names_examples"></a>

**将 SUPER 属性名称转换为大写**  
以下示例使用 UPPER\$1ATTRIBUTE\$1NAMES 来转换表中所有 SUPER 值的属性名称。

```
-- Create a table and insert several SUPER values.
CREATE TABLE t (i INT, s SUPER);

INSERT INTO t VALUES
  (1, NULL), 
  (2, 'a'::SUPER),
  (3, JSON_PARSE('{"AttributeName": "b"}')),
  (4, JSON_PARSE(
     '[{"Subobject": {"c": "c"},
        "Subarray": [{"d": "d"}, "e"]
      }]'));

-- Convert all attribute names to uppercase.
UPDATE t SET s = UPPER_ATTRIBUTE_NAMES(s);

SELECT i, s FROM t ORDER BY i;

 i |                        s
---+--------------------------------------------------
 1 | NULL
 2 | "a"
 3 | {"ATTRIBUTENAME":"B"}
 4 | [{"SUBOBJECT":{"C":"c"},"SUBARRAY":[{"D":"d"}, "e"]}]
```

观察 UPPER\$1ATTRIBUTE\$1NAMES 的工作原理。
+  NULL 值和标量 SUPER 值（例如 `"a"`）保持不变。
+  在 SUPER 对象中，所有属性名称都更改为大写，但诸如 `"b"` 之类的属性值保持不变。
+  UPPER\$1ATTRIBUTE\$1NAMES 以递归方式应用于嵌套在 SUPER 数组或其它对象内的任何 SUPER 对象。

**在具有重复属性名称的 SUPER 对象上使用 UPPER\$1ATTRIBUTE\$1NAMES**  
如果 SUPER 对象包含的属性的名称仅在大小写上有所不同，则 UPPER\$1ATTRIBUTE\$1NAMES 将引发错误。考虑以下示例。

```
SELECT UPPER_ATTRIBUTE_NAMES(JSON_PARSE('{"A": "A", "a": "a"}'));      

error:   Invalid input
code:    8001
context: SUPER value has duplicate attributes after case conversion.
```