这是本节的多页打印视图。 点击此处打印.

返回本页常规视图.

COPY

COPY 可将数据批量加载到 Vertica 数据库中。默认情况下，COPY 会自动提交自身及所有当前事务（加载临时表时除外）。如果 COPY 被中止或中断，Vertica 将予以回退。

COPY 以 UTF-8 编码格式读取数据。

有关在群集主机或客户端系统上加载一个或多个文件或管道的信息，请参阅 COPY LOCAL。

语法

COPY [ /*+ LABEL (label‑string)*/ ] [[database.]schema-name.]target-table
   [ ( { column-as-expression | column }
       [ DELIMITER [ AS ] 'char' ]
       [ ENCLOSED [ BY ] 'char' ]
       [ ENFORCELENGTH ]
       [ ESCAPE [ AS ] 'char' | NO ESCAPE ]
       [ FILLER datatype]
       [ FORMAT 'format' ]
       [ NULL [ AS ] 'string' ]
       [ TRIM 'byte' ]
       [,...] ) ]
   [ COLUMN OPTION (column
       [ DELIMITER [ AS ] 'char' ]
       [ ENCLOSED [ BY ] 'char' ]
       [ ENFORCELENGTH ]
       [ ESCAPE [ AS ] 'char' | NO ESCAPE ]
       [ FORMAT 'format' ]
       [ NULL [ AS ] 'string' ]
       [ TRIM 'byte' ]
     [,...] ) ]
FROM {
   [ LOCAL ] STDIN [ compression ]
   | { 'path-to-data'
       [ ON { nodename | (nodeset) | ANY NODE | EACH NODE } ] [ compression ] }[,...]
     [ PARTITION COLUMNS column[,...] ]
   | LOCAL 'path-to-data' [ compression ] [,...]
   | VERTICA source-database.[source-schema.]source-table[( source-column[,...] ) ]
  }
  [ NATIVE
    | FIXEDWIDTH COLSIZES {( integer )[,...]}
    | NATIVE VARCHAR
    | ORC
    | PARQUET
  ]
  | [ WITH ] UDL-clause[...]
}
   [ ABORT ON ERROR ]
   [ DELIMITER [ AS ] 'char' ]
   [ ENCLOSED [ BY ] 'char'
   [ ENFORCELENGTH ]
   [ ERROR TOLERANCE ]
   [ ESCAPE [ AS ] 'char' | NO ESCAPE ]
   [ EXCEPTIONS 'path' [ ON nodename] [,...]
   [ NULL [ AS ] 'string' ]
   [ RECORD TERMINATOR 'string' ]
   [ REJECTED DATA {'path' [ ON nodename] [,...] | AS TABLE reject-table} ]
   [ REJECTMAX integer ]
   [ SKIP integer ]
   [ SKIP BYTES integer ]
   [ STREAM NAME  'streamName']
   [ TRAILING NULLCOLS ]
   [ TRIM 'byte' ]
   [ [ WITH ] PARSER parser ([ arg=value[,...] ]) ] ]
   [ NO COMMIT ]

参数

请参阅参数。

限制

请参阅限制。

特权

超级用户具有完整的 COPY 权限。以下要求适用于非超级用户：

  • 对表的 INSERT 权限

  • 对架构的 USAGE 权限

  • 用户可访问的存储位置

  • 授予的对读取或写入文件的存储位置的相应 READ 或 WRITE 权限

COPY 可以指定一个路径来存储被拒绝的数据和异常。如果路径解析为存储位置，则以下权限适用于非超级用户：

1 - 参数

COPY 参数及其描述分为以下部分：

目标选项

以下选项适用于目标表及其列：

LABEL

将标签分配到语句，以便您可以在分析和调试时识别它。

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

在 CREATE EXTERNAL TABLE 或 CREATE FLEX EXTERNAL TABLE 语句中使用时，COPY 将忽略 schema-name。

target-table
用于加载新数据的目标列式表或 Flex 表。Vertica 将数据从架构表加载到包含列的全部投影中。
column-as-expression
用于计算目标列值的表达式，不可以是复杂类型。例如： 
=> COPY t(year AS TO_CHAR(k, 'YYYY')) FROM 'myfile.dat'

当加载到目标数据库时，使用该选项来转换数据。

有关详细信息，请参阅在加载期间转换数据。

列
限制加载至表中一个或多个指定列。如果未指定列，COPY 将默认加载所有列。

将向从列列表中忽略的表列分配其 DEFAULT 或 SET USING 值（如有）；否则，COPY 将插入 NULL。

如果将 column 参数留空以加载表中的所有列，则可以使用可选参数 COLUMN OPTION 来为特定列指定解析选项。

数据文件必须包含与 COPY 命令列列表中数量相同的列。

COLUMN OPTION
为表列列表中声明的一个或多个列指定加载元数据。例如，可以指定一个具有自己的 DELIMITER、ENCLOSED BY 或 NULL AS 等表达式的列。不必在 COLUMN OPTION 列表中显式指定每个列名称，但是指定的每一列必须对应表列列表中的列。

列选项

根据选项的指定方式，以下 COPY 选项可以对特定列或所有列进行限定。某些解析器特定选项也可以应用于特定列或所有列。有关这两种模式的详细信息，请参阅全局选项和特定于列的选项。

ENFORCELENGTH
如果指定，COPY 将拒绝 CHAR、VARCHAR、BINARY 和 VARBINARY 类型的数据行，或集合中这些类型的元素（如果集合大于声明的大小）。

默认情况下，COPY 会截断这些数据类型的违反约束的行以及集合中这些类型的元素，但不会拒绝这些行。有关更多详细信息，请参阅处理混乱数据。

如果集合不适合其所有元素，COPY 会拒绝行，但不会截断。不会减少元素的数量。如果每个元素各自都在限制范围内，但元素数量导致集合超过列的最大大小，则可能会发生这种情况。

FILLER datatype
读取但不复制输入列的数据。使用填充内容列来忽略在表中没有列的输入列。还可以使用填充内容列来转换数据（请参阅示例和在加载期间转换数据）。填充内容列不可以是复杂类型。
FORMAT 'format'
输入格式，为以下之一：

  • 八进制

  • 十六进制

  • 比特流

请参阅二进制（原生）数据了解更多关于这些格式的信息。

加载日期/时间列时，使用 FORMAT 会显著提升加载性能。COPY 与 TO_DATE 函数支持相同的格式。请参阅用于日期/时间格式化的模板模式。

如果指定了无效格式的字符串，COPY 操作将返回错误。

NULL [AS]
该字符串表示空值。默认为一个空字符串 ('')。可以将 null 值指定为 E'\000' 至 E'\177'（包含）范围内的任何 ASCII 值。不能对 DELIMITER 和 NULL 选项使用相同的字符。有关详细信息，请参阅分隔数据。

输入选项

以下选项可用于指定源数据：

LOCAL
在客户端系统上加载数据文件，而不是在群集主机上。LOCAL 可以限定 STDIN 和 path-to-data 参数。有关详细信息，请参阅COPY LOCAL。

限制： 对 CREATE EXTERNAL TABLE AS COPY

STDIN 无效
从客户端读取标准输入而非文件。STDIN 只接受一个输入源。要加载多个输入源，请使用 path-to-data。

用户必须具有表的 INSERT 权限以及架构的 USAGE 权限。

限制： 对 CREATE EXTERNAL TABLE AS COPY 无效

path-to-data
指定包含数据的文件的绝对路径，可来自多个输入源。

  • 如果文件存储在 HDFS 中，则 path-to-data webhdfs 是架构中的 URI，通常为 [[s]web]hdfs://[nameservice]/path。请参阅HDFS 文件系统。

  • 如果文件存储在 S3 存储桶中，则 path-to-data 是格式为 s3://bucket/path 的 URI。请参阅S3 对象存储。

  • 如果文件存储在 Google Cloud Storage 中，则 path-to-data 是格式为 gs://bucket/path 的 URI。请参阅Google Cloud Storage (GCS) 对象存储。

  • 如果文件存储在 Azure Blob 存储中，则 path-to-data 是格式为 azb://account/container/path 的 URI。请参阅Azure Blob 存储对象存储。

  • 如果文件位于本地 Linux 文件系统或 NFS 装载上，则 path-to-data 为本地绝对文件路径。

path-to-data 可以选择包含通配符以和多个文件匹配。文件必须可供本地客户端或 COPY 语句运行的主机访问。COPY 会跳过文件列表中的空文件。若文件列表包含目录，则会导致查询失败。请参阅指定加载数据的位置。在 Linux Manual Page for Glob (7) 中指定了通配符支持的模式，对于 ADO.net 平台，则通过 NET Directory.getFiles 方法指定。

可使用变量来构建 使用加载脚本 中描述的路径名。

如果 path-to-data 解析为本地文件系统上的存储位置，且调用 COPY 的用户为非超级用户，则将应用以下要求：

此外，如果用户具有权限但不是超级用户，并且从该存储位置调用 COPY，Vertica 会确保符号链接不会导致未经授权的访问。

PARTITION COLUMNS column[,...]
其值在目录结构中而不是在数据中指定的列。此选项在路径包含形式为 colname=value 的目录名称时有效，例如： 
/data/created=2016-01-01/*.dat
/data/created=2016-01-02/*.dat
/data/created=2016-01-03/*.dat

值通过目录名称的 value 部分进行解析。如果不能强制转换为列数据类型，该值将被拒绝。如果该值缺失，COPY 会将其加载为 null。

以下示例将这些日期与数据文件中的其他列一起加载到表列中：

=> CREATE EXTERNAL TABLE records
    (id int, name varchar(50), created date)
   AS COPY FROM 'webhdfs:///path/*/*'
   PARTITION COLUMNS created;

有关详细信息，请参阅分区文件路径。

ON nodename
指定要复制的数据所驻留的节点以及应解析加载文件的节点。如果忽略 nodename，输入文件的位置默认为启动程序节点。使用 nodename 从 COPY 启动程序节点以外的节点复制和解析加载文件。
ON (nodeset)
指定一组要在其上执行加载的节点。相同数据必须可供在所有指定节点上加载。nodeset 是括号中节点名称的逗号分隔列表。例如： 
=> COPY t FROM 'file1.txt' ON (v_vmart_node0001, v_vmart_node0002);

Vertica 将加载分摊到所有指定节点。如果同时指定了 ERROR TOLERANCE 或 REJECTMAX，Vertica 会改为选择单个节点来执行加载。

如果数据在所有节点上都可用，则通常会使用 ON ANY NODE，这是从 HDFS 和云对象存储加载所使用的默认值。但是，可以使用 ON nodeset 在并发加载之间手动平衡加载。

ON ANY NODE
指定要加载的源文件在所有节点上都可用，这样 COPY 可以打开文件并从群集的任一节点解析。对于 Eon 模式数据库，COPY 将使用与启动程序相同的子群集中的节点。

如果文件足够大，可以进行分摊，Vertica 会尝试在多个节点之间分摊加载。如果指定了 ERROR TOLERANCE 或 REJECTMAX，Vertica 将选择单个节点。

可使用通配符或 glob（如 *.dat）并结合 ON ANY NODE 子句加载多个输入文件。如果使用 glob，COPY 会将文件列表分配至所有群集节点并分散工作负载。

ON ANY NODE 对于 STDIN 和 LOCAL 无效。STDIN 只能使用客户端主机，LOCAL 表示客户端节点。

ON ANY NODE 是从 Linux 以外的所有路径（HDFS 和云对象存储）加载时使用的默认值。

ON EACH NODE
从每个节点的指定路径加载数据。当每个节点上的数据文件不同，且您想要加载所有这些文件时，请使用此选项。如果路径在所有节点上都无效，则 COPY 会加载有效路径并生成警告。如果路径是共享位置，则 COPY 仅在 ON ANY NODE 上加载一次。
compression
输入压缩类型，为以下之一：

  • UNCOMPRESSED（默认）

  • BZIP

  • GZIP

  • LZO

  • ZSTD

输入文件可以是任何格式。如果使用通配符，所有的限定输入文件必须是相同的格式。要加载不同的文件格式，则指定具体的格式类型。

以下要求和限制适用：

  • 使用串联的 BZIP 或 GZIP 文件时，确认所有的源文件在串联之前使用记录终止符终止。

  • 串联的 BZIP 和 GZIP 文件不支持 NATIVE（二进制）和 NATIVE VARCHAR 格式。

  • LZO 文件假定使用 lzop 进行压缩。Vertica 支持以下 lzop 实参：

    • --no-checksum / -F

    • --crc32

    • --adler32

    • --no-name / -n

    • --name / -N

    • --no-mode

    • --no-time

    • --fast

    • --best

    • 编号的压缩级别

  • BZIP、GZIP、ZSTD 和 LZO 压缩不能与 ORC 格式结合使用。

VERTICA
请参阅COPY FROM VERTICA。
[WITH] UDL-clause[...]
指定一个或多个用户定义的加载函数、一个源和（可选）一个或多个筛选器和一个解析器，如下所示： 
SOURCE source( [arg=value[,...] ]
[ FILTER filter( [arg=value[,...] ] ) ]...
[ PARSER parser( [arg=value[,...] ] ) ]

要为列表使用 Flex 表解析器，请使用 PARSER 参数，后跟 Flex 表解析器实参。有关支持的 Flex 表解析器，请参阅将数据批量加载到 Flex 表中。

处理选项

以下选项用于控制 COPY 如何处理不同的突发事件：

ABORT ON ERROR
指定如果有任何行被拒绝，则停止 COPY。语句将被回滚，并且不加载数据。
COLSIZES (integer[,...])
加载固定宽度数据时指定列宽。COPY 要求在使用 FIXEDWIDTH 解析器时指定 COLSIZES。COLSIZES 与整数列表必须与表列列表中所列出的列对应。有关详细信息，请参阅固定宽度格式数据。
ERROR TOLERANCE
指定加载数据时，COPY 在执行过程中独立处理每个源。如果单个源无效，则语句不会回滚。将跳过无效的源，并继续加载。

使用此参数可禁用分摊加载。

限制： 对 ORC 或 Parquet 数据无效

EXCEPTIONS
指定文件名或要写入异常的文件的绝对路径，如下所示： 
EXCEPTIONS 'path' [ ON nodename[,...]]

异常描述了每个被拒绝的行被拒绝的原因。每个异常描述了通过 REJECTED DATA 选项指定的文件中的相应记录。

文件将被写入执行加载的一个或多个节点上。如果文件已经存在，其将被覆盖。

要收集某个位置的所有异常，请使用 REJECTED DATA AS TABLE 子句，异常会自动列在表的 rejected_reason 列中。

ON nodename 子句将 nodename 上的现有异常文件移至同一节点上所示的 path。有关详细信息，请参阅保存加载异常 (EXCEPTIONS)。

如果将此参数与 COPY...ON ANY NODE 一起使用，则仍必须为异常文件指定单独的节点，如以下示例中所示：

EXCEPTIONS '/home/ex01.txt' on v_db_node0001,'/home/ex02.txt'
on v_db_node0002,'/home/ex03.txt' on v_db_node0003

如果 path 解析为存储位置，则以下权限适用于非超级用户：

REJECTED DATA
指定在何处写入加载失败的每一行。如果指定此参数，则将始终写入由于解析错误而失败的记录。仅当设置了配置参数 CopyFaultTolerantExpressions 时，才会写入由于转换过程中的错误而失败的记录。

此参数的语法为：

REJECTED DATA
{ 'path' [ ON nodename ] [,...] | AS TABLE reject-table }

Vertica 可以将被拒绝的数据写入指定路径或表：

  • 'path' [ON nodename]：将被拒绝的行数据复制到执行加载的节点上的指定路径。如果通过 ON nodename 进行限定，Vertica 会将 nodename 上现有的被拒绝的数据文件移至同一节点上的 path。

    path 的值可以是目录，也可以是文件前缀。如果存在多个加载源，会始终将 path 视为目录。如果不存在多个加载源，但 path 以 '/' 结尾，或者如果该名称的目录已经存在，则也会将其视为目录。否则，会将 path 视为文件前缀。

    文件将被写入执行加载的一个或多个节点上。如果文件已经存在，其将被覆盖。

    当将此参数与 LOCAL 结合使用时，输出将写入客户端。

  • AS TABLE reject-table：将被拒绝的行保存到 reject-table。

有关这两个选项的详细信息，请参阅处理杂乱的数据。

REJECTMAX integer
加载失败前可以拒绝的逻辑记录的最大数量。有关详细信息，请参阅处理杂乱的数据。

REJECTMAX 禁用分摊加载。

SKIP integer
要在加载文件中跳过的记录的数量。例如，可以使用 SKIP 选项来省略表头信息。

限制： 对 ORC 或 Parquet 数据无效

STREAM NAME
提供 COPY 加载流标识符。使用流名称有助于快速识别特定加载。您在加载语句中提供的 STREAM NAME 值将出现在系统表 LOAD_STREAMS 和 LOAD_SOURCES 的 STREAM_NAME 列中。

无效的流名称包含长度最多为 128 字节的字母数字字符或特殊字符组合。

例如：

=> COPY mytable FROM myfile 
   DELIMITER '|' STREAM NAME 'My stream name';
WITH parser
指定批量加载列式表时要使用的解析器，为以下之一：

默认情况下，COPY 在 UTF-8 格式下使用 DELIMITER 解析器，分隔文本输入数据。如果未直接指定 DELIMITER 解析器，则缺少特定解析器将表示使用默认设置。

要为列表使用 Flex 表解析器，请使用 PARSER 参数，后跟 Flex 表解析器实参。有关支持的 Flex 表解析器，请参阅将数据批量加载到 Flex 表中。

加载到 Flex 表时，必须使用兼容的解析器。有关支持的 Flex 表解析器，请参阅将数据批量加载到 Flex 表中。

COPY LOCAL 不支持 NATIVE、NATIVE VARCHAR、ORC 和 PARQUET 解析器。

有关复杂数据类型支持的解析器，请参阅特定解析器的文档。

有关解析器的详细信息，请参阅数据加载中的数据格式。

NO COMMIT
防止 COPY 语句在完成复制数据时自动提交事务。此选项必须是最后一个 COPY 语句参数。

有关详细信息，请参阅使用事务暂存加载。

限制： 对 ORC 或 Parquet 数据无效，将被 CREATE EXTERNAL TABLE AS COPY 忽略

解析器特定选项

以下选项仅在使用特定解析器时适用。

DELIMITED 解析器

DELIMITER

表示一个 ASCII 字符，用于分隔文件中每条记录内的各个列。您可以使用 E'\000' 到 E'\177'（包含）范围内的任何 ASCII 值。不能对 DELIMITER 和 NULL 参数使用相同的字符。有关详细信息，请参阅分隔数据。

默认值： 竖线 ('|')。

ENCLOSED [BY]

设置在要其内封装数据的引号字符，允许分隔字符嵌套在字符串值中。可选择范围包含在 E'\001' 至 E'\177'（包含）的任何 ASCII 值（包括除 NULL 以外的任何 ASCII 字符）：E'\000'）。默认情况下，ENCLOSED BY 没有值，即数据不会被任何类型的引号字符包围。

ESCAPE [AS]

设置转义字符。设置后，转义字符后面的字符将按字面意思解释，而不是解释为特殊字符。您可以使用 E'\001' 至 E'\177'（包含）范围内的任何 ASCII 值来定义转义字符（包括除 NULL 以外的任何 ASCII 字符：E'\000'）。

COPY 语句不会将它读取的数据解释为字符串字面量。它也不遵循与其他 SQL 语句（包括 COPY 参数）相同的转义规则。读入数据时，COPY 仅解释被以下选项定义为特殊值的字符：

  • ESCAPE [AS]

  • DELIMITER

  • ENCLOSED [BY]

  • RECORD TERMINATOR

  • All COLLECTION 选项

默认值： 反斜线 ('\')。

NO ESCAPE

消除转义字符处理。如果不需要任何转义字符并且想要防止数据中的字符不被解释为转义序列，则使用该选项。

RECORD TERMINATOR
指定表明数据文件记录结束的字面量字符字符串。有关使用此参数的更多信息，请参见 分隔数据。
TRAILING NULLCOLS
指定如果 Vertica 遇到的记录不具有足够数据来匹配表列列表中的列，COPY 将使用 NULL 值插入缺失的列。有关其他信息和示例，请参阅固定宽度格式数据。
COLLECTIONDELIMITER

对于集合类型的列，表示用于分隔每个集合中元素的单个 ASCII 字符。您可以使用 E'\000' 到 E'\177'（包含）范围内的任何 ASCII 值。没有任何 COLLECTION 选项可能具有与任何其他 COLLECTION 选项相同的值。有关详细信息，请参阅分隔数据。

默认值： 逗号 (',')。

COLLECTIONOPEN， COLLECTIONCLOSE

对于集合类型的列，这些选项指示标记集合开头和结尾的字符。在元素列表中的其他地方使用这些字符而不转义它们是错误的。没有任何 COLLECTION 选项可能具有与任何其他 COLLECTION 选项相同的值。

默认值： 方括号（'[' 和 ']'）。

COLLECTIONNULLELEMENT

该字符串表示集合中空元素值。可将一个 null 值指定为在范围包含在 E'\001' 至 E'\177'（包含）的任何 ASCII 值（包括除 NULL 以外的任何 ASCII 值：E'\000'）。没有任何 COLLECTION 选项可能具有与任何其他 COLLECTION 选项相同的值。有关详细信息，请参阅分隔数据。

默认值： 'null'

COLLECTIONENCLOSE

对于集合类型的列，设置在要其内封装单个元素的引号字符，允许分隔字符嵌套在字符串值中。可选择范围包含在 E'\001' 至 E'\177'（包含）的任何 ASCII 值（包括除 NULL 以外的任何 ASCII 字符）：E'\000'）。

没有任何 COLLECTION 选项可能具有与任何其他 COLLECTION 选项相同的值。

默认： 双引号（'"'）

FIXEDWIDTH 解析器

SKIP BYTES integer
要在记录中跳过的总字节数。
TRIM
截取从列中指定的字符数。此选项仅在加载固定宽度数据时可用。您可以在表级别设置列的 TRIM，或将其作为 COLUMN OPTION 参数的一部分。

2 - 限制

COPY 具有以下限制：

无效数据

COPY 认为以下数据无效：

  • 缺失列（输入行的列数少于接收表的列数）。

  • 多余列（输入行的列数多于接收表的列数）。

  • INTEGER 或 DATE/TIME 数据类型的空列。对于这些类型中的任何一种，如果某列是空的，则 COPY 将不会使用 CREATE TABLE 命令定义的默认值。但是，如果您在 COPY 语句中未提供列选项，则将使用默认值。

  • 某个数据类型的表示不正确。例如，尝试将非数字值加载到 INTEGER 列的操作是无效的。

约束违规

如果在目标表中启用了主键、唯一键或检查约束以自动强制实施，Vertica 会在您加载新数据时强制实施这些约束。如果发生违规，Vertica 会回滚操作并返回错误。

空行处理

若 COPY 在加载数据时遇到空行，则既不会插入也不会拒绝该行，但 COPY 将递增行记录编号。评估被拒绝的记录时，请考虑此行为。如果您要返回被拒绝记录的列表，而 COPY 在加载数据时遇到空行，则被拒绝记录的位置将不会递增 1，如以下示例中所示。

该示例首先将值加载到将第一列定义为 INT 的表中。请注意第 3、4 和 8 行中的错误：

=> \! cat -n /home/dbadmin/test.txt
     1 1|A|2
     2 2|B|4
     3 A|D|7
     4 A|E|7
     5
     6
     7 6|A|3
     8 B|A|3

空行（5 和 6）会将错误报告转移到第 8 行：

=> SELECT row_number, rejected_data, rejected_reason FROM test_bad;
 row_number | rejected_data | rejected_reason
------------+---------------+----------------------------------------------
          3 | A|D|7 | Invalid integer format 'A' for column 1 (c1)
          4 | A|E|7 | Invalid integer format 'A' for column 1 (c1)
          6 | B|A|3 | Invalid integer format 'B' for column 1 (c1)
(3 rows)

压缩文件错误

加载压缩文件时，如果文件似乎已损坏，则 COPY 可能会中止并报告错误。例如，读取头块失败时，可能发生此行为。

磁盘配额

表和架构可以设置磁盘配额。如果加载违反任一配额，操作将失败。有关详细信息，请参阅磁盘配额。

3 - 解析器

Vertica 支持多种解析器以加载不同类型的数据。如下所述，某些解析器仅用于 Flex 表。

3.1 - DELIMITED

使用 DELIMITED 解析器（默认）通过 COPY 加载分隔的文本数据。您可以指定分隔符、转义字符、如何处理空值以及其他参数。

DELIMITED 解析器支持读取标量类型的一维集合（数组或集）。

DELIMITED 解析器同时支持分摊加载和协作解析。

COPY 选项

以下选项特定于此解析器。有关其他适用选项，请参阅参数。

DELIMITER

表示一个 ASCII 字符，用于分隔文件中每条记录内的各个列。您可以使用 E'\000' 到 E'\177'（包含）范围内的任何 ASCII 值。不能对 DELIMITER 和 NULL 参数使用相同的字符。有关详细信息，请参阅分隔数据。

默认值： 竖线 ('|')。

ENCLOSED [BY]

设置在要其内封装数据的引号字符，允许分隔字符嵌套在字符串值中。可选择范围包含在 E'\001' 至 E'\177'（包含）的任何 ASCII 值（包括除 NULL 以外的任何 ASCII 字符）：E'\000'）。默认情况下，ENCLOSED BY 没有值，即数据不会被任何类型的引号字符包围。

ESCAPE [AS]

设置转义字符。设置后，转义字符后面的字符将按字面意思解释，而不是解释为特殊字符。您可以使用 E'\001' 至 E'\177'（包含）范围内的任何 ASCII 值来定义转义字符（包括除 NULL 以外的任何 ASCII 字符：E'\000'）。

COPY 语句不会将它读取的数据解释为字符串字面量。它也不遵循与其他 SQL 语句（包括 COPY 参数）相同的转义规则。读入数据时，COPY 仅解释被以下选项定义为特殊值的字符：

  • ESCAPE [AS]

  • DELIMITER

  • ENCLOSED [BY]

  • RECORD TERMINATOR

  • All COLLECTION 选项

默认值： 反斜线 ('\')。

NO ESCAPE

消除转义字符处理。如果不需要任何转义字符并且想要防止数据中的字符不被解释为转义序列，则使用该选项。

RECORD TERMINATOR
指定表明数据文件记录结束的字面量字符字符串。有关使用此参数的更多信息，请参见 分隔数据。
TRAILING NULLCOLS
指定如果 Vertica 遇到的记录不具有足够数据来匹配表列列表中的列，COPY 将使用 NULL 值插入缺失的列。有关其他信息和示例，请参阅固定宽度格式数据。
COLLECTIONDELIMITER

对于集合类型的列，表示用于分隔每个集合中元素的单个 ASCII 字符。您可以使用 E'\000' 到 E'\177'（包含）范围内的任何 ASCII 值。没有任何 COLLECTION 选项可能具有与任何其他 COLLECTION 选项相同的值。有关详细信息，请参阅分隔数据。

默认值： 逗号 (',')。

COLLECTIONOPEN， COLLECTIONCLOSE

对于集合类型的列，这些选项指示标记集合开头和结尾的字符。在元素列表中的其他地方使用这些字符而不转义它们是错误的。没有任何 COLLECTION 选项可能具有与任何其他 COLLECTION 选项相同的值。

默认值： 方括号（'[' 和 ']'）。

COLLECTIONNULLELEMENT

该字符串表示集合中空元素值。可将一个 null 值指定为在范围包含在 E'\001' 至 E'\177'（包含）的任何 ASCII 值（包括除 NULL 以外的任何 ASCII 值：E'\000'）。没有任何 COLLECTION 选项可能具有与任何其他 COLLECTION 选项相同的值。有关详细信息，请参阅分隔数据。

默认值： 'null'

COLLECTIONENCLOSE

对于集合类型的列，设置在要其内封装单个元素的引号字符，允许分隔字符嵌套在字符串值中。可选择范围包含在 E'\001' 至 E'\177'（包含）的任何 ASCII 值（包括除 NULL 以外的任何 ASCII 字符）：E'\000'）。

没有任何 COLLECTION 选项可能具有与任何其他 COLLECTION 选项相同的值。

默认： 双引号（'"'）

示例

以下示例显示了默认行为，其中分隔符为 '|'

=> CREATE TABLE employees (id INT, name VARCHAR(50), department VARCHAR(50));
CREATE TABLE

=> COPY employees FROM STDIN;
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> 42|Sheldon Cooper|Physics
>> 17|Howard Wolowitz|Astronomy
>> \.

=> SELECT * FROM employees;
 id |      name       |  department
----+-----------------+--------------
 17 | Howard Wolowitz | Astrophysics
 42 | Sheldon Cooper  | Physics
(2 rows)

以下示例显示如何使用默认选项加载数组值。

=> CREATE TABLE researchers (id INT, name VARCHAR, grants ARRAY[VARCHAR], values ARRAY[INT]);
CREATE TABLE

=> COPY researchers FROM STDIN;
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> 42|Sheldon Cooper|[US-7376,DARPA-1567]|[65000,135000]
>> 17|Howard Wolowitz|[NASA-1683,NASA-7867,SPX-76]|[16700,85000,45000]
>> \.

=> SELECT * FROM researchers;
 id |      name       |               grants               |       values
----+-----------------+------------------------------------+---------------------
 17 | Howard Wolowitz | ["NASA-1683","NASA-7867","SPX-76"] | [16700,85000,45000]
 42 | Sheldon Cooper  | ["US-7376","DARPA-1567"]           | [65000,135000]
(2 rows)

在以下示例中，集合括在大括号中并由句点分隔，且数组包含空值。

=> COPY researchers FROM STDIN COLLECTIONOPEN '{' COLLECTIONCLOSE '}' COLLECTIONDELIMITER '.';
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> 19|Leonard|{"us-1672".null."darpa-1963"}|{16200.null.16700}
>> \.

=> SELECT * FROM researchers;
 id |      name       |               grants               |       values
----+-----------------+------------------------------------+---------------------
 17 | Howard Wolowitz | ["NASA-1683","NASA-7867","SPX-76"] | [16700,85000,45000]
 42 | Sheldon Cooper  | ["US-7376","DARPA-1567"]           | [65000,135000]
 19 | Leonard         | ["us-1672",null,"darpa-1963"]      | [16200,null,16700]
(3 rows)

3.2 - FAVROPARSER

解析来自 Avro 文件的数据。需要满足以下要求：

  • Avro 文件必须以 Avro 二进制序列化编码格式进行编码，如 Apache Avro 标准中所述。解析器还支持 Snappy 和 deflate 压缩。

  • FAVROPARSER 不支持包含单独架构文件的 Avro 文件。Avro 文件必须包含架构。

您可以使用强类型加载 Avro 源（数组、结构或组合）中的复杂类型，或将其作为灵活的复杂类型进行加载。将灵活的复杂类型加载到 VMap 列中的操作与加载到 Flex 表中一样。要加载复杂类型作为 VMap 列，请将列类型指定为 LONG VARBINARY。要保留复杂类型的索引，请将 flatten_maps 设置为 false。

加载到 Flex 表中时，Vertica 会将所有数据加载到 __raw__ (VMap) 列中，包括数据中的复杂类型。

此解析器不支持分摊加载或协作解析。

语法

FAVROPARSER ( [parameter=value[,...]] )

参数

flatten_maps
布尔值，是否平展所有 Avro 映射。键名必须通过嵌套层连接起来。该值为递归值，且会影响加载中的所有数据。

此参数仅适用于 Flex 表或 VMap 列，且会在加载强类型复杂类型时被忽略。

默认值：true

flatten_arrays
布尔值，是否平展所有 Avro 数组。键名必须通过嵌套层连接起来。该值为递归值，且会影响加载中的所有数据。

此参数仅适用于 Flex 表或 VMap 列，且会在加载强类型复杂类型时被忽略。

默认值：false

flatten_records
布尔值，是否平展所有 Avro 记录。键名必须通过嵌套层连接起来。该值为递归值，且会影响加载中的所有数据。

此参数仅适用于 Flex 表或 VMap 列，且会在加载强类型复杂类型时被忽略。

默认值：true

reject_on_materialized_type_error

布尔值，是否拒绝包含无法强制转换为兼容数据类型的实体化列值的数据行。如果值为 false 且无法强制类型，则解析器将该列中的值设置为 null。

如果该列是强类型复杂类型，而不是可变复杂类型，则复杂类型中的类型不匹配将导致整个列被视为不匹配。解析器不会部分加载复杂类型。

默认值：false

基元数据类型

FAVROPARSER 支持以下基元数据类型，包括复杂类型中的元素类型和字段值。

Avro 逻辑类型

FAVROPARSER 支持以下 Avro 逻辑类型。目标列必须使用支持逻辑类型的 Vertica 数据类型。当尝试使用无效的逻辑类型加载数据时，将忽略此逻辑类型并使用基础 Avro 类型。

Avro 复杂数据类型

Avro 格式支持某些复杂数据类型。加载到强类型列时，您可以使用 ROW 和 ARRAY 类型来表示这些类型。例如，Avro Record 和 Enums 为结构 (ROW)；请参阅 Avro 规范。

您可以使用 ARRAY[ROW] 来匹配 Avro 映射。必须将 ROW 字段命名为 key 和 value。这些是 Avro 格式用于数据中的字段的名称，解析器通过字段名称将数据与表列进行匹配。

当加载到 Flex 表或使用灵活的复杂类型时，此解析器会按如下方式处理 Avro 复杂类型：

Record

各字段的名称被用作虚拟列名称。如果 flatten_records 为 true，且存在几个嵌套级别，Vertica 将连接 record 名称以创建键名。

Map

每个 map 键的值被用作虚拟列名称。如果 flatten_maps 为 true，且存在几个嵌套级别，Vertica 将连接所有键名以创建键名。

Enum

Vertica 将 Avro Enum 视为 record，将 Enum 的名称作为键，将其值作为值。

Array

Vertica 将 Avro Array 视为键/值对。默认情况下，每个元素的索引作为键。在以下示例中，product_detail 是一个包含字段 product_category 的 Record，即一个 Array：

=> CREATE FLEX TABLE products;
CREATE TABLE

=> COPY products FROM :datafile WITH PARSER FAVROPARSER();
 Rows Loaded
-------------
           2
(1 row)

=> SELECT MAPTOSTRING(__raw__) FROM products ORDER BY __identity__;
                    maptostring
--------------------------------------------------------------------------------
 {
    "__name__": "Order",
    "customer_id": "111222",
    "order_details": {
        "0.__name__": "OrderDetail",
        "0.product_detail.__name__": "Product",
        "0.product_detail.price": "46.21",
        "0.product_detail.product_category": {
            "0": "electronics",
            "1": "printers",
            "2": "computers"
        },
        "0.product_detail.product_description": "hp printer X11ew description :\
P",
        "0.product_detail.product_hash": "\u0000\u0001\u0002\u0003\u0004",
        "0.product_detail.product_id": "999012",
        "0.product_detail.product_map.one": "1.1",
        "0.product_detail.product_map.two": "1.1",
        "0.product_detail.product_name": "hp printer X11ew",
        "0.product_detail.product_status": "ONLY_FEW_LEFT",
        "0.quantity": "3",
        "0.total": "354.34"
    },
    "order_id": "2389646",
    "total": "132.43"
}
...

如果 flatten_arrays 为 true，且存在几个嵌套级别，Vertica 将连接索引以创建键名。

=> COPY products FROM :datafile WITH PARSER FAVROPARSER(flatten_arrays=true);
 Rows Loaded
-------------
           2
(1 row)

=> SELECT MAPTOSTRING(__raw__) FROM products ORDER BY __identity__;
                    maptostring
--------------------------------------------------------------------------------

 {
    "__name__": "Order",
    "customer_id": "111222",
    "order_details.0.__name__": "OrderDetail",
    "order_details.0.product_detail.__name__": "Product",
    "order_details.0.product_detail.price": "46.21",
    "order_details.0.product_detail.product_category.0": "electronics",
    "order_details.0.product_detail.product_category.1": "printers",
    "order_details.0.product_detail.product_category.2": "computers",
    "order_details.0.product_detail.product_description": "hp printer X11ew des\
cription :P",
    "order_details.0.product_detail.product_hash": "\u0000\u0001\u0002\u0003\u0\
004",
    "order_details.0.product_detail.product_id": "999012",
    "order_details.0.product_detail.product_map.one": "1.1",
    "order_details.0.product_detail.product_map.two": "1.1",
    "order_details.0.product_detail.product_name": "hp printer X11ew",
    "order_details.0.product_detail.product_status": "ONLY_FEW_LEFT",
    "order_details.0.quantity": "3",
    "order_details.0.total": "354.34",
    "order_id": "2389646",
    "total": "132.43"
}
...

Union

Vertica 将 Avro Union 视为 Array。

示例

此示例演示了如何使用 favroparser 创建 Flex 表并将 Avro 数据加载到其中。加载数据后，您可以查询虚拟列：

=> CREATE FLEX TABLE avro_basic();
CREATE TABLE

=> COPY avro_basic FROM '/home/dbadmin/data/weather.avro' PARSER FAVROPARSER();
Rows Loaded
-------------
5
(1 row)

=> SELECT station, temp, time FROM avro_basic;
station | temp |     time
---------+------+---------------
mohali  | 0    | -619524000000
lucknow | 22   | -619506000000
norwich | -11  | -619484400000
ams     | 111  | -655531200000
baddi   | 78   | -655509600000
(5 rows)

有关详细信息，请参阅Avro 数据。

3.3 - FJSONPARSER

解析并加载 JSON 文件。此文件可能包含重复的 JSON 数据对象（包括嵌套映射）或 JSON 元素的外部列表。

加载到 Flex 表或混合表中时，解析器将 JSON 数据存储在单值 VMap 中。加载到混合表或列式表中时，解析器将数据直接加载到列名称与 JSON 源数据键相匹配的任何表列。

您可以使用强类型加载 JSON 源（数组、结构或组合）中的复杂类型，或将其作为灵活的复杂类型加载。将灵活的复杂类型加载到 VMap 列中的操作与加载到 Flex 表中一样。要加载复杂类型作为 VMap 列，请将列类型指定为 LONG VARBINARY。要保留复杂类型的索引，请将 flatten_maps 设置为 false。

仅当指定了 record_terminator 时，FJSONPARSER 才支持 协作解析。它不支持分摊加载。

语法

FJSONPARSER ( [parameter=value[,...]] )

参数

flatten_maps
布尔值，是否将 JSON 数据中的子映射平展，以句点 (.) 分隔映射层级。此值会影响加载中的所有数据，包括嵌套映射。

此参数仅适用于 Flex 表或 VMap 列，且会在加载强类型复杂类型时被忽略。

默认值：true

flatten_arrays
布尔值，是否将列表转换为带有整数键的子映射。列表被平展后，键名会像映射一样连接起来。默认不对列表进行平展。此值影响加载中的所有数据，包括嵌套列表。

此参数仅适用于 Flex 表或 VMap 列，且会在加载强类型复杂类型时被忽略。

默认值：false

reject_on_duplicate
布尔值，是忽略重复记录 (false)，还是拒绝重复记录 (true)。在任何一种情况下，都会继续加载。

默认值：false

reject_on_empty_key
布尔值，是否拒绝包含的字段键不含值的任何行。

默认值：false

omit_empty_keys
布尔值，是否忽略数据中不含值的任何字段键。同一记录中的其他字段将加载。

默认值：false

record_terminator
设置后，将跳过所有无效的 JSON 记录，并继续解析下一个记录。必须统一终止记录。例如，如果您的输入文件包含通过换行符终止的 JSON 记录，请将此参数设置为 E'\n')。如果存在任何无效的 JSON 记录，则在下一个 record_terminator 之后继续解析。

即使数据不包含无效的记录，也可以指定显式记录终止符，这样可以提高协作解析和分摊加载的运行效率，从而提升加载性能。

如果忽略此参数，解析将在第一条无效 JSON 记录处结束。

reject_on_materialized_type_error

布尔值，是否拒绝包含无法强制转换为兼容数据类型的实体化列值的数据行。如果值为 false 且无法强制类型，则解析器将该列中的值设置为 null。

如果该列是强类型复杂类型，而不是可变复杂类型，则复杂类型中的类型不匹配将导致整个列被视为不匹配。解析器不会部分加载复杂类型。

默认值：false

start_point
字符串，即 JSON 加载数据中用作解析起点的键的名称。解析器忽略 start_point 值之前的所有数据。将为文件中的每个对象加载该值。解析器会处理第一个实例后面的数据，最多到第二个，便会忽略任何保留的数据。
start_point_occurrence
整数，您通过 start_point 指定的值的第 n 次出现。如果数据具有多个起始值，而且您知道要在其第几次出现时开始解析，请与 start_point 结合使用。

默认值： 1

suppress_nonalphanumeric_key_chars
布尔值，是否禁止显示 JSON 键值中的非字母数字字符。当此参数为 true 时，解析器将用下划线 (_) 替换这些字符。

默认值：false

key_separator
解析器在连接键名时要使用的字符。

默认： 句点 (.)

示例

以下示例使用默认参数从 STDIN 加载 JSON 数据：

=> CREATE TABLE people(age INT, name VARCHAR);
CREATE TABLE

=> COPY people FROM STDIN PARSER FJSONPARSER();
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> {"age": 5, "name": "Tim"}
>>  {"age": 3}
>>  {"name": "Fred"}
>>  {"name": "Bob", "age": 10}
>> \.
=> SELECT * FROM people;
 age | name
-----+------
     | Fred
  10 | Bob
   5 | Tim
   3 |
(4 rows)

以下示例使用 reject_on_duplicate 参数拒绝重复值：

=> CREATE FLEX TABLE json_dupes();
CREATE TABLE

=> COPY json_dupes FROM stdin PARSER fjsonparser(reject_on_duplicate=true)
exceptions '/home/dbadmin/load_errors/json_e.out'
rejected data '/home/dbadmin/load_errors/json_r.out';

Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.

>> {"a":"1","a":"2","b":"3"}
>> \.

=>  \!cat /home/dbadmin/load_errors/json_e.out
COPY: Input record 1 has been rejected (Rejected by user-defined parser).
Please see /home/dbadmin/load_errors/json_r.out, record 1 for the rejected record.
COPY: Loaded 0 rows, rejected 1 rows.

以下示例将加载数组数据：

$ cat addrs.json
 {"number": 301, "street": "Grant", "attributes": [1, 2, 3, 4]}

=> CREATE EXTERNAL TABLE customers(number INT, street VARCHAR, attributes ARRAY[INT])
    AS COPY FROM 'addrs.json' PARSER fjsonparser();

=> SELECT number, street, attributes FROM customers;
 num | street| attributes
-----+-----------+---------------
301  | Grant | [1,2,3,4]
(1 row)

以下示例将加载一个灵活的复杂类型，同时拒绝嵌套记录中具有空键的行。请注意，虽然数据包含两家餐厅，但其中一家的键名是空字符串。此餐厅将被拒绝：

$ cat rest1.json
{
    "name" : "Bob's pizzeria",
    "cuisine" : "Italian",
    "location_city" : ["Cambridge", "Pittsburgh"],
    "menu" : [{"item" : "cheese pizza", "" : "$8.25"},
              {"item" : "spinach pizza", "price" : "$10.50"}]
}
{
    "name" : "Bakersfield Tacos",
    "cuisine" : "Mexican",
    "location_city" : ["Pittsburgh"],
    "menu" : [{"item" : "veggie taco", "price" : "$9.95"},
              {"item" : "steak taco", "price" : "$10.95"}]
}

=> CREATE TABLE rest (name VARCHAR, cuisine VARCHAR, location_city LONG VARBINARY, menu LONG VARBINARY);

=> COPY rest FROM '/data/rest1.json'
    PARSER fjsonparser(flatten_maps=false, reject_on_empty_key=true);
Rows Loaded
------------
       1
(1 row)

=> SELECT maptostring(location_city), maptostring(menu) FROM rest;
        maptostring        |                          maptostring
---------------------------+-------------------------------------------------------
 {
    "0": "Pittsburgh"
} | {
    "0": {
        "item": "veggie taco",
        "price": "$9.95"
    },
    "1": {
        "item": "steak taco",
        "price": "$10.95"
    }
}
(1 row)

要改为加载部分数据，请使用 omit_empty_keys 在加载其他所有内容时绕过缺失键：



=> COPY rest FROM '/data/rest1.json'
    PARSER fjsonparser(flatten_maps=false, omit_empty_keys=true);
 Rows Loaded
-------------
           2
(1 row)

=> SELECT maptostring(location_city), maptostring(menu) from rest;
                   maptostring                   |               maptostring
-------------------------------------------------+---------------------------------
 {
    "0": "Pittsburgh"
}                       | {
    "0": {
        "item": "veggie taco",
        "price": "$9.95"
    },
    "1": {
        "item": "steak taco",
        "price": "$10.95"
    }
}
 {
    "0": "Cambridge",
    "1": "Pittsburgh"
} | {
    "0": {
        "item": "cheese pizza"
    },
    "1": {
        "item": "spinach pizza",
        "price": "$10.50"
    }
}
(2 rows)

要改为使用强类型加载此数据，请在表中定义复杂类型：

=> CREATE EXTERNAL TABLE restaurants
  (name VARCHAR, cuisine VARCHAR,
   location_city ARRAY[VARCHAR(80)],
   menu ARRAY[ ROW(item VARCHAR(80), price FLOAT) ]
  )
 AS COPY FROM '/data/rest.json' PARSER fjsonparser();

=> SELECT * FROM restaurants;
       name        | cuisine |       location_city        |                    \
                menu
-------------------+---------+----------------------------+--------------------\
--------------------------------------------------------
 Bob's pizzeria    | Italian | ["Cambridge","Pittsburgh"] | [{"item":"cheese pi\
zza","price":0.0},{"item":"spinach pizza","price":0.0}]
 Bakersfield Tacos | Mexican | ["Pittsburgh"]             | [{"item":"veggie ta\
co","price":0.0},{"item":"steak taco","price":0.0}]
(2 rows)

有关其他示例，请参阅 JSON 数据。

3.4 - ORC

使用包含 COPY 语句的 ORC 子句以 ORC 格式加载数据。将数据加载到 Vertica 时，可读取所有基元类型、UUID 和复杂类型。

加载 ORC 数据时，必须考虑数据中的所有列；不能只选择某些列。

如果表定义包含基元类型的列，且这些列不存在于数据中，则解析器将使用 NULL 填充这些列。如果表定义包含复杂类型的列，则这些列必须存在于数据中。

此解析器不支持分摊加载或协作解析。

语法

ORC ( [ parameter=value[,...] ] )

参数

所有参数均为可选参数。

hive_partition_cols
以逗号分隔的列列表，这些列是数据中的分区列。
allow_no_match
是否接受包含的 glob 没有匹配文件的路径并在查询结果中报告 0 行。如果未设置此参数，当 FROM 子句中的路径与至少一个文件不匹配时，Vertica 将返回错误。

示例

ORC 子句不使用 PARSER 选项：

=> CREATE EXTERNAL TABLE orders (...)
   AS COPY FROM 's3://DataLake/orders.orc' ORC;

可以将映射列读取为行数组，如以下示例中所示：

=> CREATE EXTERNAL TABLE orders
 (orderkey INT,
  custkey INT,
  prods ARRAY[ROW(key VARCHAR(10), value DECIMAL(12,2))],
  orderdate DATE
 ) AS COPY FROM '...' ORC;

3.5 - PARQUET

使用包含 COPY 语句的 PARQUET 解析器以 Parquet 格式加载数据。将数据加载到 Vertica 时，可读取所有基元类型、UUID 和复杂类型。

默认情况下，Parquet 解析器使用强架构匹配，这意味着数据中的列必须与使用数据的表中的列完全匹配。您可以选择使用弱架构匹配。

加载 Parquet 数据时，Vertica 会缓存 Parquet 元数据以提升效率。此缓存使用本地 TEMP 存储，如果 TEMP 为远程存储，则不使用。请参阅 ParquetMetadataCacheSizeMB 配置参数来更改缓存的大小。

此解析器不支持分摊加载或协作解析。

语法

PARQUET ( [ parameter=value[,...] ] )

参数

所有参数均为可选参数。

hive_partition_cols
以逗号分隔的列列表，这些列是数据中的分区列。
allow_no_match
Boolean。是否接受包含的 glob 没有匹配文件的路径并在查询结果中报告 0 行。如果未设置此参数，当 FROM 子句中的路径与至少一个文件不匹配时，Vertica 将返回错误。
allow_long_varbinary_match_complex_type
Boolean。是否启用灵活的列类型（请参阅可变复杂类型）。如果为 true，Parquet 解析器将允许数据中的复杂类型与定义为 LONG VARBINARY 的表列匹配。如果为 false，Parquet 解析器将需要使用复杂类型的强类型。对于参数集，仍然可以使用强类型。如果您希望将使用灵活的列视为错误，请将此参数设置为 false。
do_soft_schema_match_by_name
Boolean。是否启用弱架构匹配 (true)，而不是使用基于表定义和 parquet 文件中的列顺序的严格匹配（false，默认值）。有关详细信息，请参阅弱架构匹配。
reject_on_materialized_type_error
布尔值，仅在 do_soft_schema_match_by_name 为 true 时适用。指定在使用弱架构匹配且无法将值从数据强制转换为目标列类型时要执行的操作。值为 true（默认值）表示拒绝行；值为 false 表示使用 NULL 作为值，或者截断（对于过长的字符串）。有关强制转换类型映射，请参阅类型强制转换表。

弱架构匹配

默认情况下，Parquet 解析器使用强架构匹配。这意味着必须按照与数据中相同的顺序加载 Parquet 数据中的所有列。但是，有时您只想提取某些列，或者您希望能够适应未来 Parquet 架构中的一些更改。

使用 do_soft_schema_match_by_name 参数启用弱架构匹配。此设置具有以下影响：

  • 数据中的列通过名称与表中的列匹配。名称必须完全匹配，但不区分大小写。

  • 在 Parquet 数据中存在但不属于表定义的列将被忽略。

  • 在表定义中存在但不属于 Parquet 数据的列将用 NULL 填充。解析器在 QUERY_EVENTS 中记录 UNMATCHED_TABLE_COLUMNS_PARQUETPARSER 事件。

  • 如果 Parquet 数据中存在多个不区分大小写的相同列名，解析器将使用最后一个。（当使用通过区分大小写的工具写入的数据时，可能会出现这种情况。）

  • 列类型不需要完全匹配，只要可以将 Parquet 文件中的数据类型强制转换为表使用的类型即可。如果无法强制转换某个类型，解析器会在 QUERY_EVENTS 中记录 TYPE_MISMATCH_COLUMNS_PARQUETPARSER 事件。如果 reject_on_materialized_type_error 为 true，解析器将拒绝行。如果为 false，解析器将使用 NULL，或者对于过长的字符串值，将截断该值。

  • 可以定义但不能查询使用复杂类型（基元类型的一维数组除外）的列。

数据类型

Parquet 解析器将 Parquet 数据类型映射到 Vertica 数据类型，如下所示。

以下逻辑类型不受支持：

  • EnumLogicalType
  • IntervalLogicalType
  • JSONLogicalType
  • BSONLogicalType
  • UnknownLogicalType

Parquet 解析器支持以下物理类型的映射：

类型强制转换和弱架构匹配支持以下映射。

Vertica 仅支持 3 级编码的数组，不支持 2 级编码的数组。

示例

PARQUET 子句不使用 PARSER 选项：

=> COPY sales FROM 's3://DataLake/sales.parquet' PARQUET;

在以下示例中，数据目录不包含文件：

=> CREATE EXTERNAL TABLE customers (...)
    AS COPY FROM 'webhdfs:///data/*.parquet' PARQUET;
=> SELECT COUNT(*) FROM customers;
ERROR 7869: No files match when expanding glob: [webhdfs:///data/*.parquet]

要读取零行而不是生成错误，请使用 allow_no_match 参数：

=> CREATE EXTERNAL TABLE customers (...)
    AS COPY FROM 'webhdfs:///data/*.parquet'
       PARQUET(allow_no_match='true');
=> SELECT COUNT(*) FROM customers;
 count
-------
     0
(1 row)

要允许将复杂类型（在此示例中为菜单）作为灵活的列类型进行读取，请使用 allow_long_varbinary_match_complex_type 参数：

=> CREATE EXTERNAL TABLE restaurants
    (name VARCHAR, cuisine VARCHAR, location_city ARRAY[VARCHAR], menu LONG VARBINARY)
    AS COPY FROM '/data/rest*.parquet'
    PARQUET(allow_long_varbinary_match_complex_type='True');

要仅读取餐厅数据中的某些列，请使用弱架构匹配：

=> CREATE EXTERNAL TABLE restaurants(name VARCHAR, cuisine VARCHAR)
    AS COPY FROM '/data/rest*.parquet'
    PARQUET(allow_long_varbinary_match_complex_type='True',
            do_soft_schema_match_by_name='True');

=> SELECT * from restaurant;
       name        | cuisine
-------------------+----------
 Bob's pizzeria    | Italian
 Bakersfield Tacos | Mexican
(2 rows)

3.6 - FCEFPARSER

解析 ArcSight 通用事件格式 (CEF) 日志文件。该解析器将值直接加载到列名称与源数据键相匹配的任何表列中。该解析器可将加载到 Flex 表中的数据存储在单个 VMap 中。

该解析器仅可用于 Flex 表。所有 Flex 解析器均会将数据作为单个 VMap 存储在 LONG VARBINAR_raw__ 列中。如果某个数据行过大而无法适应该列，该数据行将被拒绝。Vertica 在加载带 NULL 指定列的数据时支持 NULL 值。

语法

FAVROPARSER ( [parameter‑name='value'[,...]] )

参数

delimiter
单字符分隔符。

默认值： ' '

record_terminator
单字符记录终止符。

**默认 **** 值： **newline

trim
布尔值，指定是否从标题名和键值中去掉空格。

默认值： true

reject_on_unescaped_delimiter
布尔值，指定是否拒绝包含非转义分隔符的行。CEF 标准不允许出现此类行。

默认值： false

示例

以下示例演示了为 CEF 数据创建 Flex 表的示例，该表包含两个实际列，eventId 和 priority。

  1. 创建 Flex 表 cefdata：

    => create flex table cefdata();
CREATE TABLE

  2. 使用 Flex 解析器 fcefparser 加载一些基本的 CEF 数据：

    => copy cefdata from stdin parser fcefparser();
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> CEF:0|ArcSight|ArcSight|2.4.1|machine:20|New alert|High|
>> \.

  3. 使用 maptostring() 函数查看 cefdata Flex 表的内容：

    => select maptostring(__raw__) from cefdata;
                  maptostring
-------------------------------------------------------------
 {
   "deviceproduct" : "ArcSight",
   "devicevendor" : "ArcSight",
   "deviceversion" : "2.4.1",
   "name" : "New alert",
   "severity" : "High",
   "signatureid" : "machine:20",
   "version" : "0"
}


(1 row)

  4. 从 cefdata Flex 表中选择一些虚拟列：

    
= select deviceproduct, severity, deviceversion from cefdata;
 deviceproduct | severity | deviceversion
---------------+----------+---------------
 ArcSight      | High     | 2.4.1
(1 row)

    有关详细信息，请参阅 通用事件格式 (CEF) 数据

    另请参阅

3.7 - FCSVPARSER

解析 CSV 格式（逗号分隔值）的数据。使用此解析器将 CSV 数据加载至列式表、Flex 表和混合表中。所有数据均必须以 Unicode UTF-8 格式进行编码。fcsvparser 解析器支持 CSV 数据的 RFC 4180 标准和其他选项，以适应 CSV 文件格式定义的变化。无效记录被拒绝。有关数据格式的详细信息，请参阅处理非 UTF-8 输入。

该解析器仅可用于 Flex 表。所有 Flex 解析器均会将数据作为单个 VMap 存储在 LONG VARBINAR_raw__ 列中。如果某个数据行过大而无法适应该列，该数据行将被拒绝。Vertica 在加载带 NULL 指定列的数据时支持 NULL 值。

语法

FCSVPARSER ( [parameter='value'[,...]] )

参数

type
解析器的默认参数值，为以下字符串之一：

  • rfc4180

  • traditional

您在加载符合 RFC 4180 标准的数据（如 MS Excel 文件）时，无须使用 type 参数。请参阅加载 CSV 数据，以了解 RFC4180 的默认参数以及您可为传统 CSV 文件指定的其他选项。

默认值： RFC4180

delimiter
用于分隔 CSV 数据中的字段的单字符值。

默认值： ,（对于 rfc4180 和 traditional）

escape
用作转义字符的单字符值，用于按字面解释数据中的下一个字符。

默认值：

  • rfc4180： "

  • traditional： \\

enclosed_by
单字符值。使用 enclosed_by 包括一个与分隔符完全相同但应该按字面解释的值。例如，如果数据分隔符为逗号 (,)，则您要在数据 ("my name is jane, and his is jim") 中使用逗号。

默认值： "

record_terminator
用于指定记录末尾的单字符值。

默认值：

  • rfc4180： \n

  • traditional： \r\n

header
布尔值，指定是否使用第一行数据作为标题列。当 header=true（默认）且不存在标题时，fcsvparser 使用默认列标题。默认标题由 ucoln 组成，其中 n 为列偏移数，第一列为 0。您可以使用 header_names 参数指定自定义列标题名称，如下所述。

如果您指定 header=false，则 fcsvparser 会将输入的第一行解析为数据，而不是列标题。

默认值： true

header_names
列标题名称列表，由解析器的分隔符参数定义的字符分隔。使用此参数可以在没有标题行的 CSV 文件中指定标题名称，或覆盖 CSV 源中存在的列名称。要覆盖一个或多个现有列名，请指定要使用的标题名称。此参数覆盖数据中的任何标题行。
trim
布尔值，指定是否从标题名和键值中去掉空格。

默认值： true

omit_empty_keys
布尔值，指定解析器如何处理没有值的标头键。如果是 true，则不加载 header 行中的空值键。

默认值： false

reject_on_duplicate
布尔值，指定是忽略重复记录 (false)，还是拒绝重复记录 (true)。在任何一种情况下，都会继续加载。

默认值：false

reject_on_empty_key
布尔值，指定是否拒绝包含的键不含值的任何行。

默认值：false

reject_on_materialized_type_error
布尔值，指定是否拒绝解析器无法强制转换为兼容数据类型的任何实体化列值。请参阅加载 CSV 数据。

默认值：false

示例

此示例展示了如何使用 fcsvparser 加载 Flex 表，构建视图，然后查询该视图。

  1. 为 CSV 数据创建 Flex 表：

    => CREATE FLEX TABLE rfc();
CREATE TABLE

  2. 使用 fcsvparser 加载来自 STDIN 的数据。指定不存在标题，然后按如下方式输入一些数据：

    => COPY rfc FROM stdin PARSER fcsvparser(header='false');
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> 10,10,20
>> 10,"10",30
>> 10,"20""5",90
>> \.

  3. 运行 compute_flextable_keys_and_build_view 函数，然后查询 rfc_view。请注意，默认的 enclosed_by 字符允许字段 ("20""5") 内出现转义字符 (")。因此，所得到的值得以正确解析。由于输入数据中不存在标题，函数为各列添加了 ucoln：

    => SELECT compute_flextable_keys_and_build_view('rfc');
                           compute_flextable_keys_and_build_view
--------------------------------------------------------------------------------------------
 Please see public.rfc_keys for updated keys
The view public.rfc_view is ready for querying
(1 row)

=> SELECT * FROM rfc_view;
 ucol0 | ucol1 | ucol2
-------+-------+-------
 10    | 10    | 20
 10    | 10    | 30
 10    | 20"5  | 90
(3 rows)

    有关使用此解析器其他参数的详细信息和示例，请参阅加载 CSV 数据。

另请参阅

3.8 - FDELIMITEDPAIRPARSER

解析分隔的数据文件。此解析器提供了解析器 fdelimitedparser 功能的一个子集。当您要加载的数据指定成对列名称且每行均有数据时，使用 fdelimitedpairparser。

该解析器仅可用于 Flex 表。所有 Flex 解析器均会将数据作为单个 VMap 存储在 LONG VARBINAR_raw__ 列中。如果某个数据行过大而无法适应该列，该数据行将被拒绝。Vertica 在加载带 NULL 指定列的数据时支持 NULL 值。

语法

FDELIMITEDPAIRPARSER ( [parameter‑name='value'[,...]] )

参数

delimiter
指定单字符分隔符。

默认值： ' '

record_terminator
指定单字符记录终止符。

默认值： 换行符

trim
布尔值，指定是否从标题名和键值中去掉空格。

默认值： true

示例

以下示例演示了为简单分隔数据创建示例 Flex 表，该表包含两个实际列，分别为 eventId 和 priority。

  1. 创建一个表：

    => create flex table CEFData(eventId int default(eventId::int), priority int default(priority::int) );
CREATE TABLE

  2. 使用 fcefparser 将示例分隔的 Micro Focus ArcSight 日志文件加载到 CEFData 表中：

    => copy CEFData from '/home/release/kmm/flextables/sampleArcSight.txt' parser fdelimitedpairparser();
Rows Loaded | 200

  3. 加载示例数据文件后，使用 maptostring() 在 CEFData 的 __raw__ 列中显示虚拟列：

    => select maptostring(__raw__) from CEFData limit 1;                                                                                                                                                                                                                                        maptostring
-----------------------------------------------------------
   "agentassetid" : "4-WwHuD0BABCCQDVAeX21vg==",
   "agentzone" : "3083",
   "agt" : "265723237",
   "ahost" : "svsvm0176",
   "aid" : "3tGoHuD0BABCCMDVAeX21vg==",
   "art" : "1099267576901",
   "assetcriticality" : "0",
   "at" : "snort_db",
   "atz" : "America/Los_Angeles",
   "av" : "5.3.0.19524.0",
   "cat" : "attempted-recon",
   "categorybehavior" : "/Communicate/Query",
   "categorydevicegroup" : "/IDS/Network",
   "categoryobject" : "/Host",
   "categoryoutcome" : "/Attempt",
   "categorysignificance" : "/Recon",
   "categorytechnique" : "/Scan",
   "categorytupledescription" : "An IDS observed a scan of a host.",
   "cnt" : "1",
   "cs2" : "3",
   "destinationgeocountrycode" : "US",
   "destinationgeolocationinfo" : "Richardson",
   "destinationgeopostalcode" : "75082",
   "destinationgeoregioncode" : "TX",
   "destinationzone" : "3133",
   "device product" : "Snort",
   "device vendor" : "Snort",
   "device version" : "1.8",
   "deviceseverity" : "2",
   "dhost" : "198.198.121.200",
   "dlat" : "329913940429",
   "dlong" : "-966644973754",
   "dst" : "3334896072",
   "dtz" : "America/Los_Angeles",
   "dvchost" : "unknown:eth1",
   "end" : "1364676323451",
   "eventid" : "1219383333",
   "fdevice product" : "Snort",
   "fdevice vendor" : "Snort",
   "fdevice version" : "1.8",
   "fdtz" : "America/Los_Angeles",
   "fdvchost" : "unknown:eth1",
   "lblstring2label" : "sig_rev",
   "locality" : "0",
   "modelconfidence" : "0",
   "mrt" : "1364675789222",
   "name" : "ICMP PING NMAP",
   "oagentassetid" : "4-WwHuD0BABCCQDVAeX21vg==",
   "oagentzone" : "3083",
   "oagt" : "265723237",
   "oahost" : "svsvm0176",
   "oaid" : "3tGoHuD0BABCCMDVAeX21vg==",
   "oat" : "snort_db",
   "oatz" : "America/Los_Angeles",
   "oav" : "5.3.0.19524.0",
   "originator" : "0",
   "priority" : "8",
   "proto" : "ICMP",
   "relevance" : "10",
   "rt" : "1099267573000",
   "severity" : "8",
   "shost" : "198.198.104.10",
   "signature id" : "[1:469]",
   "slat" : "329913940429",
   "slong" : "-966644973754",
   "sourcegeocountrycode" : "US",
   "sourcegeolocationinfo" : "Richardson",
   "sourcegeopostalcode" : "75082",
   "sourcegeoregioncode" : "TX",
   "sourcezone" : "3133",
   "src" : "3334891530",
   "start" : "1364676323451",
   "type" : "0"
}

(1 row)

  4. 选择 eventID 和 priority 实际列以及两个虚拟列 atz 和 destinationgeoregioncode：

    
=>  select eventID, priority, atz, destinationgeoregioncode from CEFData limit 10;
  eventID   | priority |         atz         | destinationgeoregioncode
------------+----------+---------------------+--------------------------
 1218325417 |        5 | America/Los_Angeles |
 1219383333 |        8 | America/Los_Angeles | TX
 1219533691 |        9 | America/Los_Angeles | TX
 1220034458 |        5 | America/Los_Angeles | TX
 1220034578 |        9 | America/Los_Angeles |
 1220067119 |        5 | America/Los_Angeles | TX
 1220106960 |        5 | America/Los_Angeles | TX
 1220142122 |        5 | America/Los_Angeles | TX
 1220312009 |        5 | America/Los_Angeles | TX
 1220321355 |        5 | America/Los_Angeles | CA
(10 rows)

另请参阅

3.9 - FDELIMITEDPARSER

使用分隔符分隔值，从而解析数据。fdelimitedparser 加载分隔数据，将其存储在单值 VMap 中。

该解析器仅可用于 Flex 表。所有 Flex 解析器均会将数据作为单个 VMap 存储在 LONG VARBINAR_raw__ 列中。如果某个数据行过大而无法适应该列，该数据行将被拒绝。Vertica 在加载带 NULL 指定列的数据时支持 NULL 值。

语法

FDLIMITEDPARSER ( [parameter‑name='value'[,...]] )

参数

delimiter
单字符分隔符。

默认值： |

record_terminator
单字符记录终止符。

默认值： \n

trim
布尔值，指定是否从标题名和键值中去掉空格。

默认值： true

header
布尔值，指定存在标题列。如果您使用此参数但不存在标题，解析器使用 col### 为列命名。

默认值： true

omit_empty_keys
布尔值，指定解析器如何处理没有值的标头键。如果 omit_empty_keys=true，则不加载 header 行中的空值键。

默认值： false

reject_on_duplicate
布尔值，指定是忽略重复记录 (false)，还是拒绝重复记录 (true)。在任何一种情况下，都会继续加载。

默认值： false

reject_on_empty_key
布尔值，指定是否拒绝包含的键不含值的任何行。

默认值： false

reject_on_materialized_type_error
布尔值，指定针对不能用解析器强制转换为兼容的数据类型的实体化列，是否拒绝该列中的任何行值。请参阅使用 Flex 表解析器。

默认值： false

treat_empty_val_as_null
布尔值，指定空字段变为 NULLs，而不是变为空字符串 ('')。

默认值： true

示例

  1. 为分隔数据创建 Flex 表：

    t=> CREATE FLEX TABLE delim_flex ();
CREATE TABLE

  2. 使用 fdelimitedparser 加载些来自 STDIN 的分隔数据，并指定逗号 (,) 列分隔符：

    => COPY delim_flex FROM STDIN parser fdelimitedparser (delimiter=',');
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> deviceproduct, severity, deviceversion
>> ArcSight, High, 2.4.1
>> \.

您现在可以在 delim_flex Flex 表中查询虚拟列：

=> SELECT deviceproduct, severity, deviceversion from delim_flex;
 deviceproduct | severity | deviceversion
---------------+----------+---------------
 ArcSight      | High     | 2.4.1
(1 row)

另请参阅

3.10 - FREGEXPARSER

解析正则表达式，将各列与指定正则表达式组的内容相匹配。

该解析器仅可用于 Flex 表。所有 Flex 解析器均会将数据作为单个 VMap 存储在 LONG VARBINAR_raw__ 列中。如果某个数据行过大而无法适应该列，该数据行将被拒绝。Vertica 在加载带 NULL 指定列的数据时支持 NULL 值。

语法

FREGEXPARSER ( pattern=[parameter‑name='value'[,...]] )

参数

pattern
指定要匹配的数据正则表达式。

默认值： 空字符串 ("")

use_jit
布尔值，指定在解析正则表达式时是否使用实时编译。

默认值：false

record_terminator
指定用于分隔输入记录的字符。

默认值： \n

logline_column
一个字符串，用于捕获包含与正则表达式相匹配的完整字符串的目标列。

默认值： 空字符串 ("")

示例

这些示例使用以下正则表达式，它们搜索包括 timestamp、date、thread_name 和 thread_id 字符串的信息。

此示例表达式加载任何 thread_id 十六进制值，无论其是否包含 0x 前缀 (<thread_id>(?:0x)?[0-9a-f]+)。

'^(?<time>\d\d\d\d-\d\d-\d\d \d\d:\d\d:\d\d\.\d+)
 (?<thread_name>[A-Za-z ]+):(?<thread_id>(?:0x)?[0-9a-f]+)
-?(?<transaction_id>[0-9a-f])?(?:[(?<component>\w+)]
\<(?<level>\w+)\> )?(?:<(?<elevel>\w+)> @[?(?<enode>\w+)]?: )
?(?<text>.*)'

  1. 创建一个 Flex 表 (vlog)，以包含 Vertica 日志文件的结果。针对此示例，我们复制了一份目录 /home/dbadmin/data/vertica.log 中的日志文件：

    => create flex table vlog1();
CREATE TABLE

  2. 将 fregexparser 用于示例正则表达式，以加载日志文件中的数据。请务必在使用此处显示的此表达式之前移除任何行字符：

    =>  copy vlog1 from '/home/dbadmin/tempdat/KMvertica.log'
PARSER FREGEXPARSER(pattern=
    '^(?<time>\d\d\d\d-\d\d-\d\d \d\d:\d\d:\d\d\.\d+)
 (?<thread_name>[A-Za-z ]+):(?<thread_id>(?:0x)?[0-9a-f]+)
-?(?<transaction_id>[0-9a-f])?(?:[(?<component>\w+)]
\<(?<level>\w+)\> )?(?:<(?<elevel>\w+)> @[?(?<enode>\w+)]?: )
?(?<text>.*)'

    

    
);

 Rows Loaded
-------------
       31049
(1 row)

  3. 成功加载数据后，将 MAPTOSTRING() 函数用于表的 __raw__ 列。查询返回的四行 (limt 4) 为使用 fregexparser 解析的 KMvertica.log 文件的正则表达式结果。输出将显示前面带或不带 0x 的 thread_id 值：

  4. => select maptostring(__raw__) from vlog1 limit 4; maptostring ------------------------------------------------------------------------------------- { "text" : " [Init] <INFO> Log /home/dbadmin/VMart/v_vmart_node0001_catalog/vertica.log opened; #2", "thread_id" : "0x7f2157e287c0", "thread_name" : "Main", "time" : "2017-03-21 23:30:01.704" } { "text" : " [Init] <INFO> Processing command line: /opt/vertica/bin/vertica -D /home/dbadmin/VMart/v_vmart_node0001_catalog -C VMart -n v_vmart_node0001 -h 10.20.100.247 -p 5433 -P 4803 -Y ipv4", "thread_id" : "0x7f2157e287c0", "thread_name" : "Main", "time" : "2017-03-21 23:30:01.704" } { "text" : " [Init] <INFO> Starting up Vertica Analytic Database v8.1.1-20170321", "thread_id" : "7f2157e287c0", "thread_name" : "Main", "time" : "2017-03-21 23:30:01.704" } { "text" : " [Init] <INFO> Compiler Version: 4.8.2 20140120 (Red Hat 4.8.2-15)", "thread_id" : "7f2157e287c0", "thread_name" : "Main", "time" : "2017-03-21 23:30:01.704" } (4 rows)

另请参阅

4 - 示例

有关其他 COPY 示例，请参阅特定解析器的参考页，包括：DELIMITED、ORC、PARQUET、FJSONPARSER 和 FAVROPARSER。

指定字符串选项

将 COPY 与 FORMAT、DELIMITER、NULL 和 ENCLOSED BY 选项结合使用：

=> COPY public.customer_dimension (customer_since FORMAT 'YYYY')
   FROM STDIN
   DELIMITER ','
   NULL AS 'null'
   ENCLOSED BY '"';

将 COPY 与 DELIMITER 和 NULL 选项结合使用。此示例设置并引用输入文件的 vsql 变量：

=> \set input_file ../myCopyFromLocal/large_table.gzip
=> COPY store.store_dimension
   FROM :input_file
   DELIMITER '|'
   NULL ''
   RECORD TERMINATOR E'\f';

包括多个源文件

创建一个表，然后将多个源文件复制到其中：

=> CREATE TABLE sampletab (a int);
CREATE TABLE

=> COPY sampletab FROM '/home/dbadmin/one.dat', 'home/dbadmin/two.dat';
 Rows Loaded
-------------
           2
(1 row)

使用通配符表示一组文件：

=> COPY myTable FROM 'webhdfs:///mydirectory/ofmanyfiles/*.dat';

通配符可以包含正则表达式：

=> COPY myTable FROM 'webhdfs:///mydirectory/*_[0-9]';

使用单个 COPY 语句指定多个路径：

=> COPY myTable FROM 'webhdfs:///data/sales/01/*.dat', 'webhdfs:///data/sales/02/*.dat',
    'webhdfs:///data/sales/historical.dat';

分布加载

加载所有节点共享的数据。如果可能，Vertica 会将加载操作分布到所有节点：

=> COPY sampletab FROM '/data/file.dat' ON ANY NODE;

从两个文件中加载数据。因为第一个加载文件未指定节点（或 ON ANY NODE），因此启动程序将执行加载操作。将加载第二个文件的操作分布到所有节点：

=> COPY sampletab FROM '/data/file1.dat', '/data/file2.dat' ON ANY NODE;

为每个加载文件指定不同的节点：

=> COPY sampletab FROM '/data/file1.dat' ON (v_vmart_node0001, v_vmart_node0002),
    '/data/file2.dat' ON (v_vmart_node0003, v_vmart_node0004);

从共享存储中加载数据

要从共享存储中加载数据，请使用相应架构中的 URL：

  • HDFS： [[s]web]hdfs://[nameservice]/path

  • S3： s3://bucket/path

  • Google Cloud： gs://bucket/path

  • Azure： azb://account/container/path

使用默认名称节点或名称服务加载存储在 HDFS 中的文件：

=> COPY t FROM 'webhdfs:///opt/data/file1.dat';

通过特定的 HDFS 名称服务 (testNS) 加载数据。如果数据库配置为从多个 HDFS 群集中读取，则可以指定一个名称服务：

=> COPY t FROM 'webhdfs://testNS/opt/data/file2.csv';

从 S3 存储桶中加载数据：

=> COPY t FROM 's3://AWS_DataLake/*' ORC;

分区数据

可以使用目录结构对数据文件进行分区，例如：

path/created=2016-11-01/region=northeast/*
path/created=2016-11-01/region=central/*
path/created=2016-11-01/region=southeast/*
path/created=2016-11-01/...
path/created=2016-11-02/region=northeast/*
path/created=2016-11-02/region=central/*
path/created=2016-11-02/region=southeast/*
path/created=2016-11-02/...
path/created=2016-11-03/...
path/...

使用 PARTITION COLUMNS 选项加载分区列：

=> CREATE EXTERNAL TABLE records (id int, name varchar(50), created date, region varchar(50))
   AS COPY FROM 'webhdfs:///path/*/*/*'
   PARTITION COLUMNS created, region;

使用填充内容列

在以下示例中，该表包含名字、姓氏和全名列，但正在加载的数据包含名字、中间名和姓氏列。COPY 语句读取所有源数据，但只加载名字和姓氏的源列。它通过连接每个源数据列（包括中间名）来构造全名数据。中间名被读取为 FILLER 列，因此可以在串联中使用，但在其他情况下会被忽略。（中间名没有表格列。）

=> CREATE TABLE names(first VARCHAR(20), last VARCHAR(20), full VARCHAR(60));
CREATE TABLE
=> COPY names(first,
              middle FILLER VARCHAR(20),
              last,
              full AS first||' '||middle||' '||last)
      FROM STDIN;
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> Marc|Gregory|Smith
>> Sue|Lucia|Temp
>> Jon|Pete|Hamilton
>> \.
=> SELECT * from names;
 first |   last   |        full
-------+----------+--------------------
 Jon   | Hamilton | Jon Pete Hamilton
 Marc  | Smith    | Marc Gregory Smith
 Sue   | Temp     | Sue Lucia Temp
(3 rows)

将数据加载到 Flex 表中

创建一个 Flex 表并使用 FJSONPARSER 将 JSON 数据复制到其中：

=> CREATE FLEX TABLE darkdata();
CREATE TABLE
=> COPY tweets FROM '/myTest/Flexible/DATA/tweets_12.json' PARSER FJSONPARSER();
 Rows Loaded
-------------
          12
(1 row)

使用命名管道

COPY 支持遵循与给定文件系统上的文件名称相同的命名约定的命名管道。权限为 open、write 和 close。

创建命名管道 pipe1，并设置两个 vsql 变量：

=> \! mkfifo  pipe1
=> \set dir `pwd`/
=> \set file '''':dir'pipe1'''

从命名管道中复制一个未压缩的文件：

=> \! cat pf1.dat > pipe1 &
=> COPY large_tbl FROM :file delimiter '|';
=> SELECT * FROM large_tbl;
=> COMMIT;

加载压缩数据

从命名管道中复制一个 GZIP 文件并解压缩：

=> \! gzip pf1.dat
=> \! cat pf1.dat.gz > pipe1 &
=> COPY large_tbl FROM :file ON site01 GZIP delimiter '|';
=> SELECT * FROM large_tbl;
=> COMMIT;
=> \!gunzip pf1.dat.gz