

 从补丁 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/)。

# UNLOAD 示例
<a name="r_UNLOAD_command_examples"></a>

这些示例演示了 UNLOAD 命令的各种参数。许多示例使用 TICKIT 示例数据集。有关更多信息，请参阅 [示例数据库](c_sampledb.md)。

**注意**  
为便于阅读，这些示例包含换行符。请不要在您的 *credentials-args* 字符串中包含换行符或空格。

## 将 VENUE 卸载到竖线分隔的文件（默认分隔符）
<a name="unload-examples-venue"></a>

以下示例卸载 VENUE 表并将数据写入到 `s3://amzn-s3-demo-bucket/unload/`：

```
unload ('select * from venue')
to 's3://amzn-s3-demo-bucket/unload/'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole';
```

默认情况下，UNLOAD 为每个切片写入一个或多个文件。假定一个双节点集群中的每个节点有两个切片，上一个示例在 `amzn-s3-demo-bucket` 中会创建这些文件：

```
unload/0000_part_00
unload/0001_part_00
unload/0002_part_00
unload/0003_part_00
```

为了更好地区分输出文件，可在位置中包含前缀。以下示例卸载 VENUE 表并将数据写入到 `s3://amzn-s3-demo-bucket/unload/venue_pipe_`：

```
unload ('select * from venue')
to 's3://amzn-s3-demo-bucket/unload/venue_pipe_'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole';
```

最后在 `unload` 文件夹中生成四个文件，再次假定有四个切片。

```
venue_pipe_0000_part_00
venue_pipe_0001_part_00
venue_pipe_0002_part_00
venue_pipe_0003_part_00
```

## 将 LINEITEM 表卸载到分区的 Parquet 文件
<a name="unload-examples-partitioned-parquet"></a>

以下示例以 Parquet 格式卸载 LINEITEM 表，按 `l_shipdate` 列进行分区。

```
unload ('select * from lineitem')
to 's3://amzn-s3-demo-bucket/lineitem/'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
PARQUET
PARTITION BY (l_shipdate);
```

假设有四个切片，生成的 Parquet 文件会动态分区到不同文件夹中。

```
s3://amzn-s3-demo-bucket/lineitem/l_shipdate=1992-01-02/0000_part_00.parquet
                                             0001_part_00.parquet
                                             0002_part_00.parquet
                                             0003_part_00.parquet
s3://amzn-s3-demo-bucket/lineitem/l_shipdate=1992-01-03/0000_part_00.parquet
                                             0001_part_00.parquet
                                             0002_part_00.parquet
                                             0003_part_00.parquet
s3://amzn-s3-demo-bucket/lineitem/l_shipdate=1992-01-04/0000_part_00.parquet
                                             0001_part_00.parquet
                                             0002_part_00.parquet
                                             0003_part_00.parquet
...
```

**注意**  
在某些情况下，UNLOAD 命令使用的是 INCLUDE 选项，如以下 SQL 语句所示。  

```
unload ('select * from lineitem')
to 's3://amzn-s3-demo-bucket/lineitem/'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
PARQUET
PARTITION BY (l_shipdate) INCLUDE;
```
在这些情况下，`l_shipdate` 列也在 Parquet 文件中的数据中。否则，`l_shipdate` 列数据不在 Parquet 文件中。

## 将 VENUE 表卸载到 JSON 文件
<a name="unload-examples-json"></a>

以下示例卸载了 VENUE 表并将 JSON 格式的数据写入到 `s3://amzn-s3-demo-bucket/unload/`。

```
unload ('select * from venue')
to 's3://amzn-s3-demo-bucket/unload/'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
JSON;
```

以下是 VENUE 表中的示例行。

```
venueid | venuename                  | venuecity       | venuestate | venueseats
--------+----------------------------+-----------------+------------+-----------
      1 | Pinewood Racetrack         | Akron           | OH         | 0
      2 | Columbus "Crew" Stadium    | Columbus        | OH         | 0
      4 | Community, Ballpark, Arena | Kansas City     | KS         | 0
```

卸载到 JSON 后，文件的格式类似于以下形式。

```
{"venueid":1,"venuename":"Pinewood Racetrack","venuecity":"Akron","venuestate":"OH","venueseats":0}
{"venueid":2,"venuename":"Columbus \"Crew\" Stadium ","venuecity":"Columbus","venuestate":"OH","venueseats":0}
{"venueid":4,"venuename":"Community, Ballpark, Arena","venuecity":"Kansas City","venuestate":"KS","venueseats":0}
```

## 将 VENUE 上传到 CSV 文件
<a name="unload-examples-csv"></a>

以下示例卸载 VENUE 表并将 CSV 格式的数据写入到 `s3://amzn-s3-demo-bucket/unload/`。

```
unload ('select * from venue')
to 's3://amzn-s3-demo-bucket/unload/'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
CSV;
```

假设 VENUE 表包含以下行。

```
venueid | venuename                  | venuecity       | venuestate | venueseats
--------+----------------------------+-----------------+------------+-----------
      1 | Pinewood Racetrack         | Akron           | OH         | 0
      2 | Columbus "Crew" Stadium    | Columbus        | OH         | 0
      4 | Community, Ballpark, Arena | Kansas City     | KS         | 0
```

卸载文件类似于以下内容。

```
1,Pinewood Racetrack,Akron,OH,0
2,"Columbus ""Crew"" Stadium",Columbus,OH,0
4,"Community, Ballpark, Arena",Kansas City,KS,0
```

## 将 VENUE 卸载到使用分隔符的 CSV 文件
<a name="unload-examples-csv-delimiter"></a>

以下示例卸载 VENUE 表并使用竖线字符 (\$1) 作为分隔符以 CSV 格式写入数据。卸载的文件将写入到 `s3://amzn-s3-demo-bucket/unload/`。此示例中的 VENUE 表在第一行 (`Pinewood Race|track`) 的值中包含竖线字符。这样做是为了表明结果中的值已用双引号引起来。双引号由双引号进行转义，整个字段用双引号引起来。

```
unload ('select * from venue')
to 's3://amzn-s3-demo-bucket/unload/'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
CSV DELIMITER AS '|';
```

假设 VENUE 表包含以下行。

```
venueid | venuename                  | venuecity       | venuestate | venueseats
--------+----------------------------+-----------------+------------+-------------
      1 | Pinewood Race|track        | Akron           | OH         | 0
      2 | Columbus "Crew" Stadium    | Columbus        | OH         | 0
      4 | Community, Ballpark, Arena | Kansas City     | KS         | 0
```

卸载文件类似于以下内容。

```
1|"Pinewood Race|track"|Akron|OH|0
2|"Columbus ""Crew"" Stadium"|Columbus|OH|0
4|Community, Ballpark, Arena|Kansas City|KS|0
```

## 使用清单文件卸载 VENUE
<a name="unload-examples-manifest"></a>

要创建清单文件，请包含 MANIFEST 选项。以下示例卸载 VENUE 表，并将清单文件与数据文件一起写入到 s3://amzn-s3-demo-bucket/venue\$1pipe\$1：

**重要**  
如果使用 MANIFEST 选项卸载文件，则应在加载文件时将 MANIFEST 选项与 COPY 命令结合使用。如果您使用相同的前缀来加载文件且不指定 MANIFEST 选项，则 COPY 将失败，因为它假定清单文件是数据文件。

```
unload ('select * from venue')
to 's3://amzn-s3-demo-bucket/venue_pipe_' iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
manifest;
```

最后生成下面的 5 个文件：

```
s3://amzn-s3-demo-bucket/venue_pipe_0000_part_00
s3://amzn-s3-demo-bucket/venue_pipe_0001_part_00
s3://amzn-s3-demo-bucket/venue_pipe_0002_part_00
s3://amzn-s3-demo-bucket/venue_pipe_0003_part_00
s3://amzn-s3-demo-bucket/venue_pipe_manifest
```

下面显示了清单文件的内容。

```
{
  "entries": [
    {"url":"s3://amzn-s3-demo-bucket/tickit/venue_0000_part_00"},
    {"url":"s3://amzn-s3-demo-bucket/tickit/venue_0001_part_00"},
    {"url":"s3://amzn-s3-demo-bucket/tickit/venue_0002_part_00"},
    {"url":"s3://amzn-s3-demo-bucket/tickit/venue_0003_part_00"}
  ]
}
```

## 使用 MANIFEST VERBOSE 卸载 VENUE
<a name="unload-examples-manifest-verbose"></a>

指定 MANIFEST VERBOSE 选项时，清单文件包含以下部分：
+ `entries` 部分列出每个文件的 Amazon S3 路径、文件大小和行数。
+ `schema` 部分列出每列的列名、数据类型和维度。
+ `meta` 部分显示所有文件的总文件大小和行数。

以下示例使用 MANIFEST VERBOSE 选项卸载 VENUE 表。

```
unload ('select * from venue')
to 's3://amzn-s3-demo-bucket/unload_venue_folder/'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
manifest verbose;
```

下面显示了清单文件的内容。

```
{
  "entries": [
    {"url":"s3://amzn-s3-demo-bucket/venue_pipe_0000_part_00", "meta": { "content_length": 32295, "record_count": 10 }},
    {"url":"s3://amzn-s3-demo-bucket/venue_pipe_0001_part_00", "meta": { "content_length": 32771, "record_count": 20 }},
    {"url":"s3://amzn-s3-demo-bucket/venue_pipe_0002_part_00", "meta": { "content_length": 32302, "record_count": 10 }},
    {"url":"s3://amzn-s3-demo-bucket/venue_pipe_0003_part_00", "meta": { "content_length": 31810, "record_count": 15 }}
  ],
  "schema": {
    "elements": [
      {"name": "venueid", "type": { "base": "integer" }},
      {"name": "venuename", "type": { "base": "character varying", 25 }},
      {"name": "venuecity", "type": { "base": "character varying", 25 }},
      {"name": "venuestate", "type": { "base": "character varying", 25 }},
      {"name": "venueseats", "type": { "base": "character varying", 25 }}
    ]
  },
  "meta": {
    "content_length": 129178,
    "record_count": 55
  },
  "author": {
    "name": "Amazon Redshift",
    "version": "1.0.0"
  }
}
```

## 使用标题卸载 VENUE
<a name="unload-examples-header"></a>

以下示例使用标题行卸载 VENUE。

```
unload ('select * from venue where venueseats > 75000')
to 's3://amzn-s3-demo-bucket/unload/'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
header
parallel off;
```

下面显示了带标题行的输出文件的内容。

```
venueid|venuename|venuecity|venuestate|venueseats
6|New York Giants Stadium|East Rutherford|NJ|80242
78|INVESCO Field|Denver|CO|76125
83|FedExField|Landover|MD|91704
79|Arrowhead Stadium|Kansas City|MO|79451
```

## 将 VENUE 卸载到较小的文件
<a name="unload-examples-maxfilesize"></a>

默认情况下，文件的最大大小为 6.2 GB。如果卸载数据大于 6.2GB，UNLOAD 将为每个 6.2GB 数据段创建一个新文件。要创建较小的文件，请包括 MAXFILESIZE 参数。假设上一个示例中的数据大小为 20 GB，则下面的 UNLOAD 命令将创建 20 个文件，每个文件的大小为 1 GB。

```
unload ('select * from venue')
to 's3://amzn-s3-demo-bucket/unload/'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
maxfilesize 1 gb;
```

## 连续卸载 VENUE
<a name="unload-examples-serial"></a>

要连续卸载，请指定 PARALLEL OFF。然后，UNLOAD 将一次写入一个文件，每个文件的大小最多为 6.2 GB。

以下示例连续卸载 VENUE 表并将数据写入到 `s3://amzn-s3-demo-bucket/unload/`。

```
unload ('select * from venue')
to 's3://amzn-s3-demo-bucket/unload/venue_serial_'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
parallel off;
```

最后生成一个名为 venue\$1serial\$1000 的文件。

如果卸载数据大于 6.2GB，UNLOAD 将为每个 6.2GB 数据段创建一个新文件。以下示例连续卸载 LINEORDER 表并将数据写入到 `s3://amzn-s3-demo-bucket/unload/`。

```
unload ('select * from lineorder')
to 's3://amzn-s3-demo-bucket/unload/lineorder_serial_'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
parallel off gzip;
```

最后生成下面的一系列文件。

```
lineorder_serial_0000.gz
lineorder_serial_0001.gz
lineorder_serial_0002.gz
lineorder_serial_0003.gz
```

为了更好地区分输出文件，可在位置中包含前缀。以下示例卸载 VENUE 表并将数据写入到 `s3://amzn-s3-demo-bucket/venue_pipe_`：

```
unload ('select * from venue')
to 's3://amzn-s3-demo-bucket/unload/venue_pipe_'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole';
```

最后在 `unload` 文件夹中生成四个文件，再次假定有四个切片。

```
venue_pipe_0000_part_00
venue_pipe_0001_part_00
venue_pipe_0002_part_00
venue_pipe_0003_part_00
```

## 从卸载文件中加载 VENUE
<a name="unload-examples-load"></a>

要从一组卸载文件加载表，只需使用 COPY 命令反向执行该过程即可。以下示例创建一个名为 LOADVENUE 的新表，并从上一个示例中创建的数据文件加载该表。

```
create table loadvenue (like venue);

copy loadvenue from 's3://amzn-s3-demo-bucket/venue_pipe_' iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole';
```

如果您使用 MANIFEST 选项通过卸载文件创建清单文件，则可使用相同的清单文件加载数据。您可以使用带有 MANIFEST 选项的 COPY 命令执行此操作。以下示例使用清单文件加载数据。

```
copy loadvenue
from 's3://amzn-s3-demo-bucket/venue_pipe_manifest' iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
manifest;
```

## 将 VENUE 卸载到加密文件
<a name="unload-examples-unload-encrypted"></a>

以下示例使用 AWS KMS 密钥将 VENUE 表卸载到一组加密文件。如果您使用 ENCRYPTED 选项来指定清单文件，清单文件也将加密。有关更多信息，请参阅 [卸载加密的数据文件](t_unloading_encrypted_files.md)。

```
unload ('select * from venue')
to 's3://amzn-s3-demo-bucket/venue_encrypt_kms'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
kms_key_id '1234abcd-12ab-34cd-56ef-1234567890ab'
manifest
encrypted;
```

以下示例使用根对称密钥将 VENUE 表卸载到一组加密文件。

```
unload ('select * from venue')
to 's3://amzn-s3-demo-bucket/venue_encrypt_cmk'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
master_symmetric_key 'EXAMPLEMASTERKEYtkbjk/OpCwtYSx/M4/t7DMCDIK722'
encrypted;
```

## 从加密文件中加载 VENUE
<a name="unload-examples-load-encrypted"></a>

要从使用带有 ENCRYPT 选项的 UNLOAD 创建的一组文件中加载表，请使用 COPY 命令逆向执行该过程。对于该命令，应使用 ENCRYPTED 选项并指定用于 UNLOAD 命令的相同根对称密钥。以下示例从上一个示例创建的加密数据文件中加载 LOADVENUE 表。

```
create table loadvenue (like venue);

copy loadvenue
from 's3://amzn-s3-demo-bucket/venue_encrypt_manifest'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
master_symmetric_key 'EXAMPLEMASTERKEYtkbjk/OpCwtYSx/M4/t7DMCDIK722'
manifest
encrypted;
```

## 将 VENUE 数据卸载到制表符分隔的文件
<a name="unload-examples-venue-tab"></a>

```
unload ('select venueid, venuename, venueseats from venue')
to 's3://amzn-s3-demo-bucket/venue_tab_'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
delimiter as '\t';
```

输出数据文件如下所示：

```
1	Toyota Park	Bridgeview	IL	0
2	Columbus Crew Stadium	Columbus	OH	0
3	RFK Stadium	Washington	DC	0
4	CommunityAmerica Ballpark	Kansas City	KS	0
5	Gillette Stadium	Foxborough	MA	68756
...
```

## 将 VENUE 卸载到固定宽度的数据文件
<a name="unload-venue-fixed-width"></a>

```
unload ('select * from venue')
to 's3://amzn-s3-demo-bucket/venue_fw_'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
fixedwidth as 'venueid:3,venuename:39,venuecity:16,venuestate:2,venueseats:6';
```

输出数据文件类似于以下内容。

```
1  Toyota Park              Bridgeview  IL0
2  Columbus Crew Stadium    Columbus    OH0
3  RFK Stadium              Washington  DC0
4  CommunityAmerica BallparkKansas City KS0
5  Gillette Stadium         Foxborough  MA68756
...
```

## 将 VENUE 卸载到一组制表符分隔的 GZIP 压缩文件
<a name="unload-examples-venue-gzip"></a>

```
unload ('select * from venue')
to 's3://amzn-s3-demo-bucket/venue_tab_'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
delimiter as '\t'
gzip;
```

## 将 VENUE 卸载到 GZIP 压缩文本文件
<a name="unload-examples-venue-extension-gzip"></a>

```
unload ('select * from venue')
to 's3://amzn-s3-demo-bucket/venue_tab_'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
extension 'txt.gz'
gzip;
```

## 卸载包含分隔符的数据
<a name="unload-examples-delimiter"></a>

此示例使用 ADDQUOTES 选项卸载逗号分隔的数据，其中一些实际数据字段中包含逗号。

首先，创建一个包含引号的表。

```
create table location (id int, location char(64));

insert into location values (1,'Phoenix, AZ'),(2,'San Diego, CA'),(3,'Chicago, IL');
```

然后，使用 ADDQUOTES 选项卸载数据。

```
unload ('select id, location from location')
to 's3://amzn-s3-demo-bucket/location_'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
delimiter ',' addquotes;
```

卸载的数据文件如下所示：

```
1,"Phoenix, AZ"
2,"San Diego, CA"
3,"Chicago, IL"
...
```

## 卸载联接查询的结果
<a name="unload-examples-join"></a>

以下示例卸载包含窗口函数的联接查询的结果。

```
unload ('select venuecity, venuestate, caldate, pricepaid,
sum(pricepaid) over(partition by venuecity, venuestate
order by caldate rows between 3 preceding and 3 following) as winsum
from sales join date on sales.dateid=date.dateid
join event on event.eventid=sales.eventid
join venue on event.venueid=venue.venueid
order by 1,2')
to 's3://amzn-s3-demo-bucket/tickit/winsum'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole';
```

输出文件如下所示：

```
Atlanta|GA|2008-01-04|363.00|1362.00
Atlanta|GA|2008-01-05|233.00|2030.00
Atlanta|GA|2008-01-06|310.00|3135.00
Atlanta|GA|2008-01-08|166.00|8338.00
Atlanta|GA|2008-01-11|268.00|7630.00
...
```

## 使用 NULL AS 进行卸载
<a name="unload-examples-null-as"></a>

默认情况下，UNLOAD 将 null 值作为空字符串输出。以下示例说明如何使用 NULL AS 来将文本字符串替换为 null 值。

对于这些示例，我们将向 VENUE 表添加几个 null 值。

```
update venue set venuestate = NULL
where venuecity = 'Cleveland';
```

从 VENUESTATE 为 null 的 VENUE 中选择，以验证列是否包含 NULL。

```
select * from venue where venuestate is null;

 venueid |        venuename         | venuecity | venuestate | venueseats
---------+--------------------------+-----------+------------+------------
      22 | Quicken Loans Arena      | Cleveland |            |          0
     101 | Progressive Field        | Cleveland |            |      43345
      72 | Cleveland Browns Stadium | Cleveland |            |      73200
```

现在，使用 NULL AS 选项对 VENUE 表执行 UNLOAD 以便将 null 值替换为字符串“`fred`”。

```
unload ('select * from venue')
to 's3://amzn-s3-demo-bucket/nulls/'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
null as 'fred';
```

以下来自卸载文件的示例说明已将 null 值替换为 `fred`。这证明 VENUESEATS 的一些值也为 null，并且已替换为 `fred`。即使 VENUESEATS 的数据类型为整数，UNLOAD 也会将值转换为卸载文件中的文本，然后 COPY 会将其转换回整数。如果卸载到固定宽度的文件，则 NULL AS 字符串不得大于字段宽度。

```
248|Charles Playhouse|Boston|MA|0
251|Paris Hotel|Las Vegas|NV|fred
258|Tropicana Hotel|Las Vegas|NV|fred
300|Kennedy Center Opera House|Washington|DC|0
306|Lyric Opera House|Baltimore|MD|0
308|Metropolitan Opera|New York City|NY|0
  5|Gillette Stadium|Foxborough|MA|5
 22|Quicken Loans Arena|Cleveland|fred|0
101|Progressive Field|Cleveland|fred|43345
...
```

要从卸载文件加载表，请使用带相同 NULL AS 选项的 COPY 命令。

**注意**  
如果您尝试将 null 加载到定义为 NOT NULL 的列中，则 COPY 命令将失败。

```
create table loadvenuenulls (like venue);

copy loadvenuenulls from 's3://amzn-s3-demo-bucket/nulls/'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
null as 'fred';
```

要确认列包含 null 而不仅仅是包含空字符串，请从 LOADVENUENULLS 中选择并针对 null 进行筛选。

```
select * from loadvenuenulls where venuestate is null or venueseats is null;

 venueid |        venuename         | venuecity | venuestate | venueseats
---------+--------------------------+-----------+------------+------------
      72 | Cleveland Browns Stadium | Cleveland |            |      73200
     253 | Mirage Hotel             | Las Vegas | NV         |
     255 | Venetian Hotel           | Las Vegas | NV         |
      22 | Quicken Loans Arena      | Cleveland |            |          0
     101 | Progressive Field        | Cleveland |            |      43345
     251 | Paris Hotel              | Las Vegas | NV         |

...
```

您可以使用默认 NULL AS 行为对包含 null 的表执行 UNLOAD 操作，然后使用默认 NULL AS 行为对数据执行 COPY 以复制回表中；不过，目标表中的任何非数字字段将包含空字符串而不是 null。默认情况下，UNLOAD 将 null 转换为空字符串（空格或零长度）。对于数字列，COPY 会将空字符串转换为 NULL，但会将空字符串插入非数字列中。以下示例说明如何在执行 COPY 后使用默认 NULL AS 行为执行 UNLOAD。

```
unload ('select * from venue')
to 's3://amzn-s3-demo-bucket/nulls/'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole' allowoverwrite;

truncate loadvenuenulls;
copy loadvenuenulls from 's3://amzn-s3-demo-bucket/nulls/'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole';
```

在本示例中，当您针对 null 进行筛选时，仅显示那些 VENUESEATS 包含 null 的行。其中，VENUESTATE 在表 (VENUE) 中包含 null，目标表 (LOADVENUENULLS) 中的 VENUESTATE 包含空字符串。

```
select * from loadvenuenulls where venuestate is null or venueseats is null;

 venueid |        venuename         | venuecity | venuestate | venueseats
---------+--------------------------+-----------+------------+------------
     253 | Mirage Hotel             | Las Vegas | NV         |
     255 | Venetian Hotel           | Las Vegas | NV         |
     251 | Paris Hotel              | Las Vegas | NV         |
...
```

要将空字符串作为 NULL 加载到非数字列，请包含 EMPTYASNULL 或 BLANKSASNULL 选项。可以同时使用这两个选项。

```
unload ('select * from venue')
to 's3://amzn-s3-demo-bucket/nulls/'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole' allowoverwrite;

truncate loadvenuenulls;
copy loadvenuenulls from 's3://amzn-s3-demo-bucket/nulls/'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole' EMPTYASNULL;
```

要确认列包含 NULL，而不只是包含空格或空字符串，请从 LOADVENUENULLS 中选择并针对 null 进行筛选。

```
select * from loadvenuenulls where venuestate is null or venueseats is null;

 venueid |        venuename         | venuecity | venuestate | venueseats
---------+--------------------------+-----------+------------+------------
      72 | Cleveland Browns Stadium | Cleveland |            |      73200
     253 | Mirage Hotel             | Las Vegas | NV         |
     255 | Venetian Hotel           | Las Vegas | NV         |
      22 | Quicken Loans Arena      | Cleveland |            |          0
     101 | Progressive Field        | Cleveland |            |      43345
     251 | Paris Hotel              | Las Vegas | NV         |
     ...
```

## 使用 ALLOWOVERWRITE 参数卸载
<a name="unload-examples-allowoverwrite"></a>

默认情况下，UNLOAD 不会覆盖目标桶中的现有文件。例如，如果您运行同一个 UNLOAD 语句两次，而不修改目标桶中的文件，则第二次运行 UNLOAD 时将失败。要覆盖现有文件（包括清单文件），请指定 ALLOWOVERWRITE 选项。

```
unload ('select * from venue')
to 's3://amzn-s3-demo-bucket/venue_pipe_'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
manifest allowoverwrite;
```

## 使用 PARALLEL 和 MANIFEST 参数卸载 EVENT 表
<a name="unload-examples-manifest-parallel"></a>

您可以并行卸载表并生成清单文件。Amazon S3 数据文件都是在同一级别创建的，且名称以模式 `0000_part_00` 为后缀。清单文件与数据文件位于同一文件夹级别，并以文本 `manifest` 为后缀。以下 SQL 卸载 EVENT 表并使用基本名称 `parallel` 创建文件

```
unload ('select * from mytickit1.event')
to 's3://amzn-s3-demo-bucket/parallel'
iam_role 'arn:aws:iam::123456789012:role/MyRedshiftRole'
parallel on
manifest;
```

Amazon S3 文件列表与以下内容类似。

```
 Name                       Last modified                        Size                  
 parallel0000_part_00	-   August 2, 2023, 14:54:39 (UTC-07:00) 52.1 KB  
 parallel0001_part_00	-   August 2, 2023, 14:54:39 (UTC-07:00) 53.4 KB
 parallel0002_part_00	-   August 2, 2023, 14:54:39 (UTC-07:00) 52.1 KB
 parallel0003_part_00	-   August 2, 2023, 14:54:39 (UTC-07:00) 51.1 KB
 parallel0004_part_00	-   August 2, 2023, 14:54:39 (UTC-07:00) 54.6 KB
 parallel0005_part_00	-   August 2, 2023, 14:54:39 (UTC-07:00) 53.4 KB
 parallel0006_part_00	-   August 2, 2023, 14:54:39 (UTC-07:00) 54.1 KB
 parallel0007_part_00	-   August 2, 2023, 14:54:39 (UTC-07:00) 55.9 KB
 parallelmanifest       -   August 2, 2023, 14:54:39 (UTC-07:00) 886.0 B
```

`parallelmanifest` 文件内容类似于以下内容。

```
{
  "entries": [
    {"url":"s3://amzn-s3-demo-bucket/parallel0000_part_00", "meta": { "content_length": 53316 }},
    {"url":"s3://amzn-s3-demo-bucket/parallel0001_part_00", "meta": { "content_length": 54704 }},
    {"url":"s3://amzn-s3-demo-bucket/parallel0002_part_00", "meta": { "content_length": 53326 }},
    {"url":"s3://amzn-s3-demo-bucket/parallel0003_part_00", "meta": { "content_length": 52356 }},
    {"url":"s3://amzn-s3-demo-bucket/parallel0004_part_00", "meta": { "content_length": 55933 }},
    {"url":"s3://amzn-s3-demo-bucket/parallel0005_part_00", "meta": { "content_length": 54648 }},
    {"url":"s3://amzn-s3-demo-bucket/parallel0006_part_00", "meta": { "content_length": 55436 }},
    {"url":"s3://amzn-s3-demo-bucket/parallel0007_part_00", "meta": { "content_length": 57272 }}
  ]
}
```

## 使用 PARALLEL OFF 和 MANIFEST 参数卸载 EVENT 表
<a name="unload-examples-manifest-serial"></a>

您可以串行卸载表（PARALLEL OFF）并生成清单文件。Amazon S3 数据文件都是在同一级别创建的，且名称以模式 `0000` 为后缀。清单文件与数据文件位于同一文件夹级别，并以文本 `manifest` 为后缀。

```
unload ('select * from mytickit1.event')
to 's3://amzn-s3-demo-bucket/serial'
iam_role 'arn:aws:iam::123456789012:role/MyRedshiftRole'
parallel off
manifest;
```

Amazon S3 文件列表与以下内容类似。

```
 Name                       Last modified                        Size                  
 serial0000             -   August 2, 2023, 15:54:39 (UTC-07:00) 426.7 KB  
 serialmanifest         -   August 2, 2023, 15:54:39 (UTC-07:00) 120.0 B
```

`serialmanifest` 文件内容类似于以下内容。

```
{
  "entries": [
    {"url":"s3://amzn-s3-demo-bucket/serial000", "meta": { "content_length": 436991 }}
  ]
}
```

## 使用 PARTITION BY 和 MANIFEST 参数卸载 EVENT 表
<a name="unload-examples-manifest-partition"></a>

您可以按分区卸载表并生成清单文件。在 Amazon S3 中创建了一个包含子分区文件夹的新文件夹，子文件夹中的数据文件的名称模式类似于 `0000_par_00`。清单文件与子文件夹位于同一文件夹级别，其名称为 `manifest`。

```
unload ('select * from mytickit1.event')
to 's3://amzn-s3-demo-bucket/partition'
iam_role 'arn:aws:iam::123456789012:role/MyRedshiftRole'
partition by (eventname)
manifest;
```

Amazon S3 文件列表与以下内容类似。

```
 Name                   Type     Last modified                        Size                  
 partition           	Folder
```

在 `partition` 文件夹中是具有分区名称的子文件夹和清单文件。下面显示的是 `partition` 文件夹中文件夹列表的底部，类似于下面的内容。

```
 Name                   Type      Last modified                        Size                  
 ...
 eventname=Zucchero/    Folder 
 eventname=Zumanity/    Folder 
 eventname=ZZ Top/      Folder  
 manifest          	    -	    August 2, 2023, 15:54:39 (UTC-07:00) 467.6 KB
```

在 `eventname=Zucchero/` 文件夹中是类似于以下内容的数据文件。

```
 Name               Last modified                        Size                  
 0000_part_00	-   August 2, 2023, 15:59:19 (UTC-07:00) 70.0 B
 0001_part_00	-   August 2, 2023, 15:59:16 (UTC-07:00) 106.0 B
 0002_part_00	-   August 2, 2023, 15:59:15 (UTC-07:00) 70.0 B
 0004_part_00	-   August 2, 2023, 15:59:17 (UTC-07:00) 141.0 B
 0006_part_00	-   August 2, 2023, 15:59:16 (UTC-07:00) 35.0 B
 0007_part_00	-   August 2, 2023, 15:59:19 (UTC-07:00) 108.0 B
```

`manifest` 文件内容的底部类似于以下内容。

```
{
  "entries": [
    ...
    {"url":"s3://amzn-s3-demo-bucket/partition/eventname=Zucchero/007_part_00", "meta": { "content_length": 108 }},
    {"url":"s3://amzn-s3-demo-bucket/partition/eventname=Zumanity/007_part_00", "meta": { "content_length": 72 }}
  ]
}
```

## 使用 MAXFILESIZE、ROWGROUPSIZE 和 MANIFEST 参数卸载 EVENT 表
<a name="unload-examples-manifest-maxsize"></a>

您可以并行卸载表并生成清单文件。Amazon S3 数据文件都是在同一级别创建的，且名称以模式 `0000_part_00` 为后缀。生成的 Parquet 数据文件限制为 256MB，行组大小限制为 128MB。清单文件与数据文件位于同一文件夹级别，并以 `manifest` 为后缀。

```
unload ('select * from mytickit1.event')
to 's3://amzn-s3-demo-bucket/eventsize'
iam_role 'arn:aws:iam::123456789012:role/MyRedshiftRole'
maxfilesize 256 MB
rowgroupsize 128 MB
parallel on
parquet
manifest;
```

Amazon S3 文件列表与以下内容类似。

```
 Name                            Type      Last modified                        Size 
 eventsize0000_part_00.parquet	parquet	August 2, 2023, 17:35:21 (UTC-07:00) 24.5 KB
 eventsize0001_part_00.parquet	parquet	August 2, 2023, 17:35:21 (UTC-07:00) 24.8 KB
 eventsize0002_part_00.parquet	parquet	August 2, 2023, 17:35:21 (UTC-07:00) 24.4 KB
 eventsize0003_part_00.parquet	parquet	August 2, 2023, 17:35:21 (UTC-07:00) 24.0 KB
 eventsize0004_part_00.parquet	parquet	August 2, 2023, 17:35:21 (UTC-07:00) 25.3 KB
 eventsize0005_part_00.parquet	parquet	August 2, 2023, 17:35:21 (UTC-07:00) 24.8 KB
 eventsize0006_part_00.parquet	parquet	August 2, 2023, 17:35:21 (UTC-07:00) 25.0 KB
 eventsize0007_part_00.parquet	parquet	August 2, 2023, 17:35:21 (UTC-07:00) 25.6 KB
 eventsizemanifest                 -       August 2, 2023, 17:35:21 (UTC-07:00) 958.0 B
```

`eventsizemanifest` 文件内容类似于以下内容。

```
{
  "entries": [
    {"url":"s3://amzn-s3-demo-bucket/eventsize0000_part_00.parquet", "meta": { "content_length": 25130 }},
    {"url":"s3://amzn-s3-demo-bucket/eventsize0001_part_00.parquet", "meta": { "content_length": 25428 }},
    {"url":"s3://amzn-s3-demo-bucket/eventsize0002_part_00.parquet", "meta": { "content_length": 25025 }},
    {"url":"s3://amzn-s3-demo-bucket/eventsize0003_part_00.parquet", "meta": { "content_length": 24554 }},
    {"url":"s3://amzn-s3-demo-bucket/eventsize0004_part_00.parquet", "meta": { "content_length": 25918 }},
    {"url":"s3://amzn-s3-demo-bucket/eventsize0005_part_00.parquet", "meta": { "content_length": 25362 }},
    {"url":"s3://amzn-s3-demo-bucket/eventsize0006_part_00.parquet", "meta": { "content_length": 25647 }},
    {"url":"s3://amzn-s3-demo-bucket/eventsize0007_part_00.parquet", "meta": { "content_length": 26256 }}
  ]
}
```