从补丁 198 开始，Amazon Redshift 将不再支持创建新的 Python UDF。现有的 Python UDF 将继续正常运行至 2026 年 6 月 30 日。有关更多信息，请参阅[博客文章](https://www.amazonaws.cn/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/)。

# SUPER 类型信息函数
<a name="c_Type_Info_Functions"></a>

接着，您可以找到 Amazon Redshift 支持的 SQL 的类型信息函数的描述，以从 `SUPER` 数据类型的输入中派生动态信息。

**Topics**
+ [

# DECIMAL\$1PRECISION 函数
](r_decimal_precision.md)
+ [

# DECIMAL\$1SCALE 函数
](r_decimal_scale.md)
+ [

# IS\$1ARRAY 函数
](r_is_array.md)
+ [

# IS\$1BIGINT 函数
](r_is_bigint.md)
+ [

# IS\$1BOOLEAN 函数
](r_is_boolean.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)
+ [

# JSON\$1SIZE 函数
](r_json_size.md)
+ [

# JSON\$1TYPEOF 函数
](r_json_typeof.md)
+ [

# SIZE
](r_SIZE.md)

# DECIMAL\$1PRECISION 函数
<a name="r_decimal_precision"></a>

检查要存储的最大小数位数总数的精度。此数字包括小数点的左侧和右侧数字。精度范围为 1 到 38，默认值为 38。

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

```
DECIMAL_PRECISION(super_expression)
```

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

*super\$1expression*  
`SUPER` 表达式或列。

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

`INTEGER`

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

要将 DECIMAL\$1PRECISION 函数应用于表 t，请使用以下示例。

```
CREATE TABLE t(s SUPER);

INSERT INTO t VALUES (3.14159);

SELECT DECIMAL_PRECISION(s) FROM t;

+-------------------+
| decimal_precision |
+-------------------+
|                 6 |
+-------------------+
```

# DECIMAL\$1SCALE 函数
<a name="r_decimal_scale"></a>

检查要存储在小数点右侧的小数位数。小数位数范围从 0 到精度点，默认值为 0。

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

```
DECIMAL_SCALE(super_expression)
```

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

*super\$1expression*  
`SUPER` 表达式或列。

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

`INTEGER`

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

要将 DECIMAL\$1SCALE 函数应用于表 t，请使用以下示例。

```
CREATE TABLE t(s SUPER);

INSERT INTO t VALUES (3.14159);

SELECT DECIMAL_SCALE(s) FROM t;

+---------------+
| decimal_scale |
+---------------+
|             5 |
+---------------+
```

# IS\$1ARRAY 函数
<a name="r_is_array"></a>

检查变量是否为数组。如果变量是数组，则函数返回 `true`。该函数还包括空数组。否则，对于所有其他值，包括 null，函数返回 `false`。

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

```
IS_ARRAY(super_expression)
```

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

*super\$1expression*  
`SUPER` 表达式或列。

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

`BOOLEAN`

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

要使用 IS\$1ARRAY 函数检查 `[1,2]` 是否为数组，请使用以下示例。

```
SELECT IS_ARRAY(JSON_PARSE('[1,2]'));

+----------+
| is_array |
+----------+
| true     |
+----------+
```

# IS\$1BIGINT 函数
<a name="r_is_bigint"></a>

检查某个值是否为 `BIGINT`。对于 64 位范围内的小数位数 0 的数量，IS\$1BIGINT 函数将返回 `true`。否则，对于所有其他值，包括 null 和浮点数，该函数将返回 `false`。

IS\$1BIGINT 函数是 IS\$1INTEGER 的超集。

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

```
IS_BIGINT(super_expression)
```

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

*super\$1expression*  
`SUPER` 表达式或列。

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

`BOOLEAN`

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

要使用 IS\$1BIGINT 函数检查 `5` 是否为 `BIGINT`，请使用以下示例。

```
CREATE TABLE t(s SUPER);

INSERT INTO t VALUES (5);

SELECT s, IS_BIGINT(s) FROM t;

+---+-----------+
| s | is_bigint |
+---+-----------+
| 5 | true      |
+---+-----------+
```

# IS\$1BOOLEAN 函数
<a name="r_is_boolean"></a>

检查某个值是否为 `BOOLEAN`。对于常量 JSON 布尔值，IS\$1BOOLEAN 函数返回 `true`。对于任何其他值，包括 null，该函数返回 `false`。

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

```
IS_BOOLEAN(super_expression)
```

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

*super\$1expression*  
`SUPER` 表达式或列。

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

`BOOLEAN`

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

要使用 IS\$1BOOLEAN 函数检查 `TRUE` 是否为 `BOOLEAN`，请使用以下示例。

```
CREATE TABLE t(s SUPER);

INSERT INTO t VALUES (TRUE);

SELECT s, IS_BOOLEAN(s) FROM t;

+------+------------+
|  s   | is_boolean |
+------+------------+
| true | true       |
+------+------------+
```

# IS\$1CHAR 函数
<a name="r_is_char"></a>

检查某个值是否为 `CHAR`。对于仅包含 ASCII 字符的字符串，IS\$1CHAR 函数返回 `true`，因为 CHAR 类型只能存储 ASCII 格式的字符。对于任何其他值，该函数返回 `false`。

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

```
IS_CHAR(super_expression)
```

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

*super\$1expression*  
`SUPER` 表达式或列。

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

`BOOLEAN`

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

要使用 IS\$1CHAR 函数检查 `t` 是否为 `CHAR`，请使用以下示例。

```
CREATE TABLE t(s SUPER);

INSERT INTO t VALUES ('t');

SELECT s, IS_CHAR(s) FROM t;

+-----+---------+
|  s  | is_char |
+-----+---------+
| "t" | true    |
+-----+---------+
```

# IS\$1DECIMAL 函数
<a name="r_is_decimal"></a>

检查某个值是否为 `DECIMAL`。对于非浮点的数值，IS\$1DECIMAL 函数返回 `true`。对于任何其他值，包括 null，该函数返回 `false`。

IS\$1DECIMAL 函数是 IS\$1BIGINT 的超集。

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

```
IS_DECIMAL(super_expression)
```

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

*super\$1expression*  
`SUPER` 表达式或列。

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

`BOOLEAN`

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

要使用 IS\$1DECIMAL 函数检查 `1.22` 是否为 `DECIMAL`，请使用以下示例。

```
CREATE TABLE t(s SUPER);

INSERT INTO t VALUES (1.22);

SELECT s, IS_DECIMAL(s) FROM t;

+------+------------+
|  s   | is_decimal |
+------+------------+
| 1.22 | true       |
+------+------------+
```

# IS\$1FLOAT 函数
<a name="r_is_float"></a>

检查值是否为浮点数。对于浮点数（`FLOAT4` 和 `FLOAT8`），IS\$1FLOAT 函数返回 `true`。对于任何其他值，该函数返回 `false`。

IS\$1DECIMAL 集和 IS\$1FLOAT 集是不相交的。

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

```
IS_FLOAT(super_expression)
```

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

*super\$1expression*  
`SUPER` 表达式或列。

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

`BOOLEAN`

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

要使用 IS\$1FLOAT 函数检查 `2.22::FLOAT` 是否为 `FLOAT`，请使用以下示例。

```
CREATE TABLE t(s SUPER);

INSERT INTO t VALUES(2.22::FLOAT);

SELECT s, IS_FLOAT(s) FROM t;

+---------+----------+
|    s    | is_float |
+---------+----------+
| 2.22e+0 | true     |
+---------+----------+
```

# IS\$1INTEGER 函数
<a name="r_is_integer"></a>

对于 32 位范围内的小数位数 0 的数量，返回 `true`；对于其他任何值（包括 null 和浮点数），则返回 `false`。

IS\$1INTEGER 函数是 IS\$1SMALLINT 函数的超集。

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

```
IS_INTEGER(super_expression)
```

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

*super\$1expression*  
`SUPER` 表达式或列。

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

`BOOLEAN`

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

要使用 IS\$1INTEGER 函数检查 `5` 是否为 `INTEGER`，请使用以下示例。

```
CREATE TABLE t(s SUPER);

INSERT INTO t VALUES (5);

SELECT s, IS_INTEGER(s) FROM t;

+---+------------+
| s | is_integer |
+---+------------+
| 5 | true       |
+---+------------+
```

# IS\$1OBJECT 函数
<a name="r_is_object"></a>

检查变量是否为对象。对于包括空对象在内的对象，IS\$1OBJECT 函数返回 `true`。对于任何其他值，包括 null，该函数返回 `false`。

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

```
IS_OBJECT(super_expression)
```

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

*super\$1expression*  
`SUPER` 表达式或列。

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

`BOOLEAN`

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

要使用 IS\$1OBJECT 函数检查 `{"name": "Joe"}` 是否为对象，请使用以下示例。

```
CREATE TABLE t(s super);

INSERT INTO t VALUES (JSON_PARSE('{"name": "Joe"}'));

SELECT s, IS_OBJECT(s) FROM t;

+----------------+-----------+
|       s        | is_object |
+----------------+-----------+
| {"name":"Joe"} | true      |
+----------------+-----------+
```

# IS\$1SCALAR 函数
<a name="r_is_scalar"></a>

检查变量是否为标量。对于非数组或对象的任何值，IS\$1SCALAR 函数返回 `true`。对于任何其他值，包括 null，该函数返回 `false`。

IS\$1ARRAY、IS\$1OBJECT 和 IS\$1SCALAR 的集合覆盖除 null 之外的所有值。

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

```
IS_SCALAR(super_expression)
```

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

*super\$1expression*  
`SUPER` 表达式或列。

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

`BOOLEAN`

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

要使用 IS\$1SCALAR 函数检查 `{"name": "Joe"}` 是否为标量，请使用以下示例。

```
CREATE TABLE t(s SUPER);

INSERT INTO t VALUES (JSON_PARSE('{"name": "Joe"}'));

SELECT s, IS_SCALAR(s.name) FROM t;

+----------------+-----------+
|       s        | is_scalar |
+----------------+-----------+
| {"name":"Joe"} | true      |
+----------------+-----------+
```

# IS\$1SMALLINT 函数
<a name="r_is_smallint"></a>

检查变量是否为 `SMALLINT`。对于 16 位范围内的小数位数 0 的数量，IS\$1SMALLINT 函数返回 `true`。对于任何其他值，包括 null 和浮点数，该函数返回 `false`。

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

```
IS_SMALLINT(super_expression)
```

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

*super\$1expression*  
`SUPER` 表达式或列。

## Return
<a name="r_is_smallint-returns"></a>

`BOOLEAN`

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

要使用 IS\$1SMALLINT 函数检查 `5` 是否为 `SMALLINT`，请使用以下示例。

```
CREATE TABLE t(s SUPER);

INSERT INTO t VALUES (5);

SELECT s, IS_SMALLINT(s) FROM t;

+---+-------------+
| s | is_smallint |
+---+-------------+
| 5 | true        |
+---+-------------+
```

# IS\$1VARCHAR 函数
<a name="r_is_varchar"></a>

检查变量是否为 `VARCHAR`。对于所有字符串，IS\$1VARCHAR 函数返回 `true`。对于任何其他值，该函数返回 `false`。

IS\$1VARCHAR 函数是 IS\$1CHAR 函数的超集。

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

```
IS_VARCHAR(super_expression)
```

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

*super\$1expression*  
`SUPER` 表达式或列。

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

`BOOLEAN`

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

要使用 IS\$1VARCHAR 函数检查 `abc` 是否为 `VARCHAR`，请使用以下示例。

```
CREATE TABLE t(s SUPER);

INSERT INTO t VALUES ('abc');

SELECT s, IS_VARCHAR(s) FROM t;

+-------+------------+
|   s   | is_varchar |
+-------+------------+
| "abc" | true       |
+-------+------------+
```

# JSON\$1SIZE 函数
<a name="r_json_size"></a>

当序列化为字符串时，JSON\$1SIZE 函数返回给定 `SUPER` 表达式中的字节数。

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

```
JSON_SIZE(super_expression)
```

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

*super\$1expression*  
`SUPER` 常量或表达式。

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

`INTEGER`  
JSON\$1SIZE 函数返回一个 `INTEGER`，表示输入字符串中的字节数。此值不同于字符数。例如，UTF-8 字符 ⬤（黑点）的大小为 3 字节，即使它是 1 个字符也是如此。

## 使用说明
<a name="r_json_size-usage_notes"></a>

JSON\$1SIZE(x) 在功能上与 OCTET\$1LENGTH(JSON\$1SERIALIZE) 相同。但请注意，如果提供的 `SUPER` 表达式在序列化时超过系统的 `VARCHAR` 限制，JSON\$1SERIALIZE 会返回错误。JSON\$1SIZE 没有这个限制。

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

要返回序列化为字符串的 `SUPER` 值的长度，请使用以下示例。

```
SELECT JSON_SIZE(JSON_PARSE('[10001,10002,"⬤"]'));

+-----------+
| json_size |
+-----------+
|        19 |
+-----------+
```

请注意，提供的 `SUPER` 表达式长度为 17 个字符，但 ⬤ 为 3 字节字符，因此 JSON\$1SIZE 返回 `19`。

# JSON\$1TYPEOF 函数
<a name="r_json_typeof"></a>

根据 `SUPER` 值的动态类型，JSON\$1TYPEOF 标量函数返回具有布尔值、数值、字符串、对象、数组或 null 的 `VARCHAR`。

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

```
JSON_TYPEOF(super_expression)
```

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

*super\$1expression*  
`SUPER` 表达式或列。

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

`VARCHAR`

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

要使用 JSON\$1TYPEOF 函数检查数组 `[1,2]` 的 JSON 类型，请使用以下示例。

```
SELECT JSON_TYPEOF(ARRAY(1,2));

+-------------+
| json_typeof |
+-------------+
| array       |
+-------------+
```

要使用 JSON\$1TYPEOF 函数检查对象 `{"name":"Joe"}` 的 JSON 类型，请使用以下示例。

```
SELECT JSON_TYPEOF(JSON_PARSE('{"name":"Joe"}'));

+-------------+
| json_typeof |
+-------------+
| object      |
+-------------+
```

# SIZE
<a name="r_SIZE"></a>

 以 `INTEGER` 形式返回 `SUPER` 类型常量或表达式的二进制内存大小。

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

```
SIZE(super_expression)
```

## 参数
<a name="r_SIZE-parameters"></a>

*super\$1expression*  
 `SUPER` 类型的常量或表达式。

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

`INTEGER`

## 示例
<a name="r_SIZE-examples"></a>

 要使用 SIZE 获取多个 `SUPER` 类型表达式的内存大小，请使用以下示例。

```
CREATE TABLE test_super_size(a SUPER);
            
INSERT INTO test_super_size 
VALUES
  (null),
  (TRUE),
  (JSON_PARSE('[0,1,2,3]')),
  (JSON_PARSE('{"a":0,"b":1,"c":2,"d":3}'))
;

SELECT a, SIZE(a) 
FROM test_super_size 
ORDER BY 2, 1;

+---------------------------+------+
|             a             | size |
+---------------------------+------+
| true                      |    4 |
| NULL                      |    4 |
| [0,1,2,3]                 |   23 |
| {"a":0,"b":1,"c":2,"d":3} |   52 |
+---------------------------+------+
```