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

返回本页常规视图.

解析器

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

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)

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 - 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 数据。

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;

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)

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) 数据

    另请参阅

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 数据。

另请参阅

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)

另请参阅

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)

另请参阅

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)

另请参阅