Flex 表数据 Helper 函数提供了直接在 Flex 表中查询数据所需的信息。计算键并利用原始数据创建视图之后，可直接在查询中使用字段名称，而不是使用映射函数提取数据。
每个 Flex 表具有两个依赖对象，一个键表和一个视图。虽然这两个对象均依赖于其父表，您可以独立删除其中任一对象。删除父表将同时移除这两个依赖项，而无需使用层叠 (CASCADE) 选项。
如果 Helper 函数与父表在内部相链接，则其可自动使用相关的表和视图。当您创建 Flex 表时，也将同时创建上述两项。您可以删除键表或视图，然后重新创建同名的对象。但如果您执行此操作，新的对象不会与父 Flex 表在内部相链接。
在这种情况下，您可以恢复这些对象到父表的内部链接。为此，请在调用 RESTORE_FLEXTABLE_DEFAULT_KEYS_TABLE_AND_VIEW 函数之前删除键表和视图。调用此函数可重新创建键表和视图。
其余 Helper 函数执行本节所述的任务。
创建或重新创建默认或用户定义键表的视图，忽略任何空键。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
BUILD_FLEXTABLE_VIEW ('[[database.]schema.]flex-table'
[ [,'view-name'] [,'user-keys-table'] ])
[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
flex_table_keys 表的当前内容构建或重建输入表的视图。flex_table_keys 默认表）映射数据创建一个自定义键表，则使用此选项。函数从 user_keys 中（而不是从 flex_table_keys 中）的键构建视图。下面的示例显示如何用 1、2 或 3 实参调用 BUILD_FLEXTABLE_VIEW。
要创建或重新创建一个默认视图：
使用输入 Flex 表调用函数：
=> SELECT BUILD_FLEXTABLE_VIEW('darkdata');
build_flextable_view
-----------------------------------------------------
The view public.darkdata_view is ready for querying
(1 row)
函数从 darkdata_keys 表创建具有默认名称 (darkdata_view) 的视图。
从新视图或更新视图查询键名：
=> SELECT "user.id" FROM darkdata_view;
user.id
-----------
340857907
727774963
390498773
288187825
164464905
125434448
601328899
352494946
(12 rows)
要使用自定义名称创建或重建视图：
用两个实参、一个输入弹性表 darkdata以及要创建的视图名称 dd_view 调用函数：
=> SELECT BUILD_FLEXTABLE_VIEW('darkdata', 'dd_view');
build_flextable_view
-----------------------------------------------
The view public.dd_view is ready for querying
(1 row)
从新视图或更新视图 (user.lang) 查询键名 (dd_view)：
=> SELECT "user.lang" FROM dd_view;
user.lang
-----------
tr
en
es
en
en
it
es
en
(12 rows)
要使用 BUILD_FLEXTABLE_VIEW 从自定义键表创建一个视图，此自定义表必须具有与默认表 (darkdata_keys) 相同的架构和表定义。使用下面三种方法中的任何一种创建一个自定义键表：
使用弹性表 (darkdata_keys) 的默认键表中的所有键创建一个柱状表：
=> CREATE TABLE new_darkdata_keys AS SELECT * FROMdarkdata_keys;
CREATE TABLE
从弹性表 (LIMIT 0) 的默认键表创建一个不含内容的柱状表 (darkdata_keys)：
=> CREATE TABLE new_darkdata_keys AS SELECT * FROM darkdata_keys LIMIT 0;
CREATE TABLE
kdb=> SELECT * FROM new_darkdata_keys;
key_name | frequency | data_type_guess
----------+-----------+-----------------
(0 rows)
从默认键表创建一个不含内容的柱状表 (LIMIT 0)，并将两个值 ('user.lang', 'user.name') 插入 key_name 列：
=> CREATE TABLE dd_keys AS SELECT * FROM darkdata_keys limit 0;
CREATE TABLE
=> INSERT INTO dd_keys (key_name) values ('user.lang');
OUTPUT
--------
1
(1 row)
=> INSERT INTO dd_keys (key_name) values ('user.name');
OUTPUT
--------
1
(1 row)
=> SELECT * FROM dd_keys;
key_name | frequency | data_type_guess
-----------+-----------+-----------------
user.lang | |
user.name | |
(2 rows)
创建一个自定义键表后，用所有实参（输入 Flex 表、新视图名称、自定义键表）调用 BUILD_FLEXTABLE_VIEW：
=> SELECT BUILD_FLEXTABLE_VIEW('darkdata', 'dd_view', 'dd_keys');
build_flextable_view
-----------------------------------------------
The view public.dd_view is ready for querying
(1 row)
查询新视图：
=> SELECT * FROM dd_view;
计算来自 flex 表 VMap 数据的虚拟列（键和值）。使用此函数可计算键，而不必创建关联的表视图。如需生成视图，请使用 COMPUTE_FLEXTABLE_KEYS_AND_BUILD_VIEW。
函数将其结果存储到关联的 Flex 键表 (
flexTableName_keys)，其中包含以下列：
key_name
frequency
data_type_guess
有关详细信息，请参阅计算 Flex 表键。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
COMPUTE_FLEXTABLE_KEYS ('[[database.]schema.]flex-table')
[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
flex-tabledata_type_guess 列中的结果取决于 EnableBetterFlexTypeGuessing 配置参数。默认情况下，参数为 1 (ON)。此设置会导致函数采用以下类型之一（以及 数据类型 中列出的其他类型）返回 data_type_guess 列中的所有非字符串键：
BOOLEAN
INTEGER
FLOAT
TIMESTAMP
DATE
将配置参数设置为 0 (OFF) 会导致函数仅返回键表 data_type_guess 列中所有值的字符串类型 ([LONG]VARCHAR) 或 ([LONG] VARBINARY)。
使用此部分中的示例 CSV 数据来比较使用或不使用 EnableBetterFlexTypeGuessing 配置参数的结果。当参数为 ON 时，该函数可以更准确地确定地图数据中的关键非字符串数据类型。该参数的默认值为 1 (ON)。
Year,Quarter,Region,Species,Grade,Pond Value,Number of Quotes,Available
2015,1,2 - Northwest Oregon & Willamette,Douglas-fir,1P,$615.12 ,12,No
2015,1,2 - Northwest Oregon & Willamette,Douglas-fir,SM,$610.78 ,12,Yes
2015,1,2 - Northwest Oregon & Willamette,Douglas-fir,2S,$596.00 ,20,Yes
2015,1,2 - Northwest Oregon & Willamette,Hemlock,P,$520.00 ,6,Yes
2015,1,2 - Northwest Oregon & Willamette,Hemlock,SM,$510.00 ,6,No
2015,1,2 - Northwest Oregon & Willamette,Hemlock,2S,$490.00 ,14,No
要比较数据类型分配结果，请完成以下步骤：
保存此 CSV 数据文件（此处保存为 trees.csv）。
创建 Flex 表 (trees) 并使用 fcsvparser 加载 trees.csv：
=> CREATE FLEX TABLE trees();
=> COPY trees FROM '/home/dbadmin/tempdat/trees.csv' PARSER fcsvparser();
将 COMPUTE_FLEXTABLE_KEYS 用于 trees Flex 表。
=> SELECT COMPUTE_FLEXTABLE_KEYS('trees');
COMPUTE_FLEXTABLE_KEYS
-----------------------------------------------
Please see public.trees_keys for updated keys
(1 row)
查询 trees_keys 表输出：
=> SELECT * FROM trees_keys;
key_name | frequency | data_type_guess
------------------+-----------+-----------------
Year | 6 | Integer
Quarter | 6 | Integer
Region | 6 | Varchar(66)
Available | 6 | Boolean
Number of Quotes | 6 | Integer
Grade | 6 | Varchar(20)
Species | 6 | Varchar(22)
Pond Value | 6 | Numeric(8,3)
(8 rows)
将 EnableBetterFlexTypeGuessing 参数设置为 0（OFF）。
再次使用 trees Flex 表调用 COMPUTE_FLEXTABLE_KEYS。
查询 trees_keys 表，将 data_type_guess 的值与之前的结果进行比较。如果没有配置参数集，所有非字符串数据类型都是各种长度的 VARCHARS：
=> SELECT * FROM trees_keys;
key_name | frequency | data_type_guess
------------------+-----------+-----------------
Year | 6 | varchar(20)
Quarter | 6 | varchar(20)
Region | 6 | varchar(66)
Available | 6 | varchar(20)
Grade | 6 | varchar(20)
Number of Quotes | 6 | varchar(20)
Pond Value | 6 | varchar(20)
Species | 6 | varchar(22)
(8 rows)
要保持非字符串数据类型的准确结果，请将 EnableBetterFlexTypeGuessing 参数重新设置为 1 (ON)。
有关 EnableBetterFlexTypeGuessing 配置参数的详细信息，请参阅 EnableBetterFlexTypeGuessing。
可合并 BUILD_FLEXTABLE_VIEW 和 COMPUTE_FLEXTABLE_KEYS 的功能，以便计算来自 Flex 表 Vmap 数据的虚拟列（键），并构建视图。使用此函数创建视图将忽略空键。如果不需要一起执行这两项操作，请改为使用单操作函数之一。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
COMPUTE_FLEXTABLE_KEYS_AND_BUILD_VIEW ('flex-table')
此示例显示如何调用 darkdata Flex 表的函数。
=> SELECT COMPUTE_FLEXTABLE_KEYS_AND_BUILD_VIEW('darkdata');
compute_flextable_keys_and_build_view
-----------------------------------------------------------------------
Please see public.darkdata_keys for updated keys
The view public.darkdata_view is ready for querying
(1 row)
使用 COMPUTE_FLEXTABLE_KEYS 或 COMPUTE_FLEXTABLE_KEYS_AND_BUILD_VIEW 实体化执行计算的 flextable_keys 表中作为 key_names 列出的虚拟列。
AUDIT() 或 AUDIT_FLEX() 函数。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
MATERIALIZE_FLEXTABLE_COLUMNS ('[[database.]schema.]flex-table' [, n-columns [, keys-table-name] ])
[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
跳过已实体化的任何列
忽略所有空键
实体化键表中的 n-columns 列
跳过已实体化的任何列
按频率降序排列实体化结果
以下示例显示了如何调用 MATERIALIZE_FLEXTABLE_COLUMNS 实体化列。首先，将 tweets 样本文件 (tweets_10000.json) 载入 flex 表 twitter_r。加载数据并计算样本 Flex 表的键以后，调用 MATERIALIZE_FLEXTABLE_COLUMNS，实体化前四列：
=> COPY twitter_r FROM '/home/release/KData/tweets_10000.json' parser fjsonparser();
Rows Loaded
-------------
10000
(1 row)
=> SELECT compute_flextable_keys ('twitter_r');
compute_flextable_keys
---------------------------------------------------
Please see public.twitter_r_keys for updated keys
(1 row)
=> SELECT MATERIALIZE_FLEXTABLE_COLUMNS('twitter_r', 4);
MATERIALIZE_FLEXTABLE_COLUMNS
-------------------------------------------------------------------------------
The following columns were added to the table public.twitter_r:
contributors
entities.hashtags
entities.urls
For more details, run the following query:
SELECT * FROM v_catalog.materialize_flextable_columns_results WHERE table_schema = 'public' and table_name = 'twitter_r';
(1 row)
例子的最后一条消息推荐查询 MATERIALIZE_FLEXTABLE_COLUMNS_RESULTS 系统表，查看列实体化的结果，如下所示：
=> SELECT * FROM v_catalog.materialize_flextable_columns_results WHERE table_schema = 'public' and table_name = 'twitter_r';
table_id | table_schema | table_name | creation_time | key_name | status | message
-------------------+--------------+------------+------------------------------+-------------------+--------+---------------------
45035996273733172 | public | twitter_r | 2013-11-20 17:00:27.945484-05| contributors | ADDED | Added successfully
45035996273733172 | public | twitter_r | 2013-11-20 17:00:27.94551-05 | entities.hashtags | ADDED | Added successfully
45035996273733172 | public | twitter_r | 2013-11-20 17:00:27.945519-05| entities.urls | ADDED | Added successfully
45035996273733172 | public | twitter_r | 2013-11-20 17:00:27.945532-05| created_at | EXISTS | Column of same name already
(4 rows)
恢复键表和视图。无论删除任一表，函数还会将键表与其关联的 Flex 表链接起来。该函数还会指示其恢复了一个对象还是同时恢复了两个对象。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
RESTORE_FLEXTABLE_DEFAULT_KEYS_TABLE_AND_VIEW ('flex-table')
flex-table此示例显示如何使用现有的 Flex 表调用此函数，还原键表和视图：
=> SELECT RESTORE_FLEXTABLE_DEFAULT_KEYS_TABLE_AND_VIEW('darkdata');
RESTORE_FLEXTABLE_DEFAULT_KEYS_TABLE_AND_VIEW
----------------------------------------------------------------------------------
The keys table public.darkdata_keys was restored successfully.
The view public.darkdata_view was restored successfully.
(1 row)
此示例描述函数恢复了 darkdata_view，但不需要恢复 darkdata_keys：
=> SELECT RESTORE_FLEXTABLE_DEFAULT_KEYS_TABLE_AND_VIEW('darkdata');
RESTORE_FLEXTABLE_DEFAULT_KEYS_TABLE_AND_VIEW
------------------------------------------------------------------------------------
The keys table public.darkdata_keys already exists and is linked to darkdata.
The view public.darkdata_view was restored successfully.
(1 row)
还原键表之后，其中没有任何内容。要填充 Flex 键，请调用 COMPUTE_FLEXTABLE_KEYS 函数。
=> SELECT * FROM darkdata_keys;
key_name | frequency | data_type_guess
----------+-----------+-----------------
(0 rows)
Flex Extractor 标量函数可处理多结构数据。每个函数均接受以下输入数据：
现有数据库内容
表
从表达式返回
直接输入
这些函数不解析来自外部文件源的数据。所有函数均返回单一 VMap 值。Extractor 函数可以返回带 NULL 指定列的数据。
用分隔符和其他可选实参提取数据，并返回单一的 VMap 值。
MAPDELIMITEDEXTRACTOR (record-value [ USING PARAMETERS param=value[,...] ])
delimiter默认值： |
header_names默认值：
ucoln，其中 n 为列偏移数，第一列以 0 开头。
trim默认值： true
treat_empty_val_as_nullNULL 而不是空字符串 ('')。
默认值： true
这些示例使用了一个简短的分隔数据集：
Name|CITY|New city|State|zip
Tom|BOSTON|boston|MA|01
Eric|Burlington|BURLINGTON|MA|02
Jamie|cambridge|CAMBRIDGE|MA|08
首先，将此数据保存为 delim.dat。
创建一个 Flex 表 dflex：
=> CREATE FLEX TABLE dflex();
CREATE TABLE
使用 COPY 加载 delim.dat 文件。使用 Flex 表 fdelimitedparser 的 header='false' 选项：
=> COPY dflex FROM '/home/release/kmm/flextables/delim.dat' parser fdelimitedparser(header='false');
Rows Loaded
-------------
4
(1 row)
创建列式表 dtab，它具有一个表示身份的 id 列、一个 delim 列和一个用于存储 VMap 的 vmap 列：
=> CREATE TABLE dtab (id IDENTITY(1,1), delim varchar(128), vmap long varbinary(512));
CREATE TABLE
使用 COPY 将 delim.dat 文件加载到 dtab 表中。MAPDELIMITEDEXTRACTOR 使用 header_names 参数以及 delimiter '!' 为示例数据指定标题行：
=> COPY dtab(delim, vmap AS MAPDELIMITEDEXTRACTOR (delim
USING PARAMETERS header_names='Name|CITY|New City|State|Zip')) FROM '/home/dbadmin/data/delim.dat'
DELIMITER '!';
Rows Loaded
-------------
4
(1 row)
将 MAPTOSTRING 用于 Flex 表 dflex，以查看 __raw__ 列内容。请注意使用中的默认标题名 (ucol0 – ucol4)，因为您在加载 Flex 表时指定 header='false'：
=> SELECT MAPTOSTRING(__raw__) FROM dflex limit 10;
maptostring
-------------------------------------------------------------------------------------
{
"ucol0" : "Jamie",
"ucol1" : "cambridge",
"ucol2" : "CAMBRIDGE",
"ucol3" : "MA",
"ucol4" : "08"
}
{
"ucol0" : "Name",
"ucol1" : "CITY",
"ucol2" : "New city",
"ucol3" : "State",
"ucol4" : "zip"
}
{
"ucol0" : "Tom",
"ucol1" : "BOSTON",
"ucol2" : "boston",
"ucol3" : "MA",
"ucol4" : "01"
}
{
"ucol0" : "Eric",
"ucol1" : "Burlington",
"ucol2" : "BURLINGTON",
"ucol3" : "MA",
"ucol4" : "02"
}
(4 rows)
再次使用 MAPTOSTRING，这次将其用于 dtab 表的 vmap 列。将此输出的结果与 Flex 表的结果进行比较。请注意，MAPTOSTRING 返回了您在加载数据时指定的 header_name 参数值：
=> SELECT MAPTOSTRING(vmap) FROM dtab;
maptostring
------------------------------------------------------------------------------------------------------------------------
{
"CITY" : "CITY",
"Name" : "Name",
"New City" : "New city",
"State" : "State",
"Zip" : "zip"
}
{
"CITY" : "BOSTON",
"Name" : "Tom",
"New City" : "boston",
"State" : "MA",
"Zip" : "02121"
}
{
"CITY" : "Burlington",
"Name" : "Eric",
"New City" : "BURLINGTON",
"State" : "MA",
"Zip" : "02482"
}
{
"CITY" : "cambridge",
"Name" : "Jamie",
"New City" : "CAMBRIDGE",
"State" : "MA",
"Zip" : "02811"
}
(4 rows)
查询 delim 列，以不同的方式查看其内容：
=> SELECT delim FROM dtab;
delim
-------------------------------------
Name|CITY|New city|State|zip
Tom|BOSTON|boston|MA|02121
Eric|Burlington|BURLINGTON|MA|02482
Jamie|cambridge|CAMBRIDGE|MA|02811
(4 rows)
提取重复 JSON 数据对象（包括嵌套映射）或具有 JSON 元素外部列表的数据的内容。您可以设置一个或多个可选参数来控制提取过程。
MAPJSONEXTRACTOR (record-value [ USING PARAMETERS param=value[,...] ])
flatten_maps.) 分隔映射层级。
默认值： true
flatten_arrays默认值： false
reject_on_duplicatefalse)，或拒绝重复记录 (true)。在任何一种情况下，加载都不受影响。
默认值： false
reject_on_empty_key默认值： false
omit_empty_keys默认值： false
start_pointstart_point 值之前的所有数据。解析器会处理第一个实例后面的数据，最多到第二个，便会忽略任何保留的数据。
默认值： 无
这些示例使用以下示例 JSON 数据：
{ "id": "5001", "type": "None" }
{ "id": "5002", "type": "Glazed" }
{ "id": "5005", "type": "Sugar" }
{ "id": "5007", "type": "Powdered Sugar" }
{ "id": "5004", "type": "Maple" }
将此示例数据保存为 bake_single.json，然后加载该文件。
创建一个 Flex 表 flexjson：
=> CREATE FLEX TABLE flexjson();
CREATE TABLE
通过 fjsonparser 解析器，使用 COPY 加载 bake_single.json 文件：
=> COPY flexjson FROM '/home/dbadmin/data/bake_single.json' parser fjsonparser();
Rows Loaded
-------------
5
(1 row)
创建列式表 coljson，它具有一个身份列 (id)、一个 json 列和一个用于存储 VMap 的 vmap 列：
=> CREATE TABLE coljson(id IDENTITY(1,1), json varchar(128), vmap long varbinary(10000));
CREATE TABLE
利用 MAPJSONEXTRACTOR，使用 COPY 将 bake_single.json 文件加载到 coljson 表中：
=> COPY coljson (json, vmap AS MapJSONExtractor(json)) FROM '/home/dbadmin/data/bake_single.json';
Rows Loaded
-------------
5
(1 row)
将 MAPTOSTRING 函数用于 Flex 表 flexjson 以将 __raw__ 列的内容输出为字符串：
=> SELECT MAPTOSTRING(__raw__) FROM flexjson limit 5;
maptostring
-----------------------------------------------------
{
"id" : "5001",
"type" : "None"
}
{
"id" : "5002",
"type" : "Glazed"
}
{
"id" : "5005",
"type" : "Sugar"
}
{
"id" : "5007",
"type" : "Powdered Sugar"
}
{
"id" : "5004",
"type" : "Maple"
}
(5 rows)
再次使用 MAPTOSTRING，这次将其用于 coljson 表的 vmap 列，并比较结果。元素顺序有所不同：
=> SELECT MAPTOSTRING(vmap) FROM coljson limit 5;
maptostring
-----------------------------------------------------
{
"id" : "5001",
"type" : "None"
}
{
"id" : "5002",
"type" : "Glazed"
}
{
"id" : "5004",
"type" : "Maple"
}
{
"id" : "5005",
"type" : "Sugar"
}
{
"id" : "5007",
"type" : "Powdered Sugar"
}
(5 rows)
使用正则表达式提取数据，并以 VMap 的形式返回结果。
MAPREGEXEXTRACTOR (record-value [ USING PARAMETERS param=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>.*)'
为了方便显示，以下示例可能包含换行符。
创建一个 Flex 表 flogs：
=> CREATE FLEX TABLE flogs();
CREATE TABLE
使用 Flex 表 fregexparser 时，利用 COPY 加载示例日志文件 (vertica.log)。请注意，此示例包括为显示长文本行而添加的行字符。
=> COPY flogs FROM '/home/dbadmin/tempdat/vertica.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
-------------
81399
(1 row)
用于返回通过正则表达式调用 MAPREGEXEXTRACTOR 的结果。输出以字符串格式返回函数的结果。
=> SELECT MAPTOSTRING(MapregexExtractor(E'2014-04-02 04:02:51.011
TM Moveout:0x2aab9000f860-a0000000002067 [Txn] <INFO>
Begin Txn: a0000000002067 \'Moveout: Tuple Mover\'' using PARAMETERS
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>.*)'
)) FROM flogs where __identity__=13;
maptostring
--------------------------------------------------------------------------------------------------
{
"component" : "Txn",
"level" : "INFO",
"text" : "Begin Txn: a0000000002067 'Moveout: Tuple Mover'",
"thread_id" : "0x2aab9000f860",
"thread_name" : "TM Moveout",
"time" : "2014-04-02 04:02:51.011",
"transaction_id" : "a0000000002067"
}
(1 row)
Flex 映射函数允许您提取和操作嵌套映射数据。
所有 Flex 映射函数的第一个实参（EMPTYMAP 和 MAPAGGREGATE 除外）均包含 VMap。VMap 可以源自 Flex 表中的 __raw__ 列，或从映射或提取函数返回。
所有映射函数（EMPTYMAP 和 MAPAGGREGATE 除外）均接受 LONG VARBINARY 或 LONG VARCHAR 映射实参。
在以下示例中，外部 MAPLOOKUP 函数对从内部 MAPLOOKUP 函数返回的 VMap 数据进行操作：
=> MAPLOOKUP(MAPLOOKUP(ret_map, 'batch'), 'scripts')
您可以将 Flex 映射函数专门用于：
Flex 表
关联的 _keys 表和 _view 视图
复杂类型 Flex 列
构建一个有一行但无键值或数据的 VMap。使用此转换函数可填充映射，而无需使用 flex 解析器。但可以使用来自 SQL 查询或存储于数据库中其他位置的映射数据。
EMPTYMAP()
创建空映射
=> SELECT EMPTYMAP();
emptymap
------------------------------------------------------------------
\001\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000
(1 row)
从现有 Flex 表创建空映射
如果从现有 flex 表创建空映射，则新映射的行数与用于创建该映射的表相同。
此示例展示了从 darkdata 表创建空映射将得到的结果，表中包含 12 行 JSON 数据：
=> SELECT EMPTYMAP() FROM darkdata;
emptymap
------------------------------------------------------------------
\001\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000
\001\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000
\001\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000
\001\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000
\001\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000
\001\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000
\001\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000
\001\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000
\001\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000
\001\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000
\001\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000
\001\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000
(12 rows)
返回从 VARCHAR 的两个输入列提供的具有键和值对的 LONG VARBINARY VMap。此函数需要 OVER 子句。
MAPAGGREGATE (keys-column1, values-column2 [USING PARAMETERS param=value[,...]])
keys-columnVMap 数据的键/值对的键的表列。值为 NULL 的键排除在外。如果存在重复键，则使用查询结果中最先出现的重复键和值，省略其他重复键和值。values-columnVMap 数据的键/值对的值的表列。max_vmap_length默认值： 130000
on_overflowmax_vmap_length 时的溢出行为。值必须为以下字符串之一：
max_vmap_length，则停止键/值对聚合。执行查询但生成的 VMap 未包含所有键/值对。当提供的 max_vmap_length 不足以存储空 VMap 时，返回的结果为 NULL。请注意，需要在 OVER 子句中指定顺序条件才能获得一致的结果。默认值： 'ERROR'
以下示例使用此输入表：
=> SELECT * FROM inventory;
product | stock
--------------+--------
Planes | 100
Trains | 50
Automobiles | 200
(3 rows)
按如下所述的方法调用 MAPAGGREGATE，返回生成的 VMap 的 raw_map 数据：
=> SELECT raw_map FROM (SELECT MAPAGGREGATE(product, stock) OVER(ORDER BY product) FROM inventory) inventory;
raw_map
------------------------------------------------------------------------------------------------------------
\001\000\000\000\030\000\000\000\003\000\000\000\020\000\000\000\023\000\000\000\026\000\000\00020010050\003
\000\000\000\020\000\000\000\033\000\000\000!\000\000\000AutomobilesPlanesTrains
(1 row)
要将返回的 raw_map 数据转换为字符串表示形式，请使用具有 MAPTOSTRING 的 MAPAGGREGATE：
=> SELECT MAPTOSTRING(raw_map) FROM (SELECT MAPAGGREGATE(product, stock) OVER(ORDER BY product) FROM
inventory) inventory;
MAPTOSTRING
--------------------------------------------------------------
{
"Automobiles": "200",
"Planes": "100",
"Trains": "50"
}
(1 row)
如果运行上述查询时将 on_overflow 保留为默认值且 max_vmap_length 小于返回的 VMap 大小，则函数返回错误消息，表示需要增加 VMap长度：
=> SELECT MAPTOSTRING(raw_map) FROM (SELECT MAPAGGREGATE(product, stock USING PARAMETERS max_vmap_length=60)
OVER(ORDER BY product) FROM inventory) inventory;
----------------------------------------------------------------------------------------------------------
ERROR 5861: Error calling processPartition() in User Function MapAggregate at [/data/jenkins/workspace
/RE-PrimaryBuilds/RE-Build-Master_2/server/udx/supported/flextable/Dict.cpp:1324], error code: 0, message:
Exception while finalizing map aggregation: Output VMap length is too small [60]. HINT: Set the parameter
max_vmap_length=71 and retry your query
切换 on_overflow 的值可更改 MAPAGGREGATE 在溢出情况下的行为方式。例如，将 on_overflow 改为 'RETURN_NULL' 可执行上述查询并返回 NULL：
SELECT raw_map IS NULL FROM (SELECT MAPAGGREGATE(product, stock USING PARAMETERS max_vmap_length=60,
on_overflow='RETURN_NULL') OVER(ORDER BY product) FROM inventory) inventory;
?column?
----------
t
(1 row)
如果 on_overflow 设置为 'TRUNCATE'，则生成的 VMap 有足够的空间容纳两个键/值对，但必须删除第三个键/值对：
SELECT raw_map IS NULL FROM (SELECT MAPAGGREGATE(product, stock USING PARAMETERS max_vmap_length=60,
on_overflow='TRUNCATE') OVER(ORDER BY product) FROM inventory) inventory;
MAPTOSTRING
---------------------------------------------
{
"Automobiles": "200",
"Planes": "100"
}
(1 row)
确定 VMap 是否含有虚拟列（键）。如果存在虚拟列，此标量函数返回 true (t)；如果不存在，则返回 false (f) 。调用 maplookup() 前确定键的存在可区分 NULL 返回。maplookup() 函数用于非存在键和具有 NULL 值的存在键。
MAPCONTAINSKEY (VMap-data, 'virtual-column-name')
VMap-data任何 Vmap 数据。Vmap 的存在形式可以是：
Flex 表的 __raw__ 列
从映射函数返回的数据（示例） MAPLOOKUP
其他数据库内容
virtual-column-name本例显示如何使用 mapcontainskey() 函数和 maplookup()。查看两个函数返回的结果。检查 maplookup() 返回的空字段是表示行 (t) 的 NULL 值还是无值 (f)：
您可以在调用 maplookup() 之前使用 mapcontainskey( ) 确定键的存在。maplookup() 函数使用 NULL 返回和具有 NULL 值的存在键，表示一个不存在的键。
=> SELECT MAPLOOKUP(__raw__, 'user.location'), MAPCONTAINSKEY(__raw__, 'user.location')
FROM darkdata ORDER BY 1;
maplookup | mapcontainskey
-----------+----------------
| t
| t
| t
| t
Chile | t
Narnia | t
Uptown.. | t
chicago | t
| f
| f
| f
| f
(12 rows)
确定 VMap 是否含有指定值。如果值存在，则使用此标量函数返回 true (t)，否则返回 false (f)。
MAPCONTAINSVALUE (VMap-data, 'virtual-column-value')
任何 Vmap 数据。Vmap 的存在形式可以是：
Flex 表的 __raw__ 列
从映射函数返回的数据（示例） MAPLOOKUP
其他数据库内容
本例显示如何使用 mapcontainsvalue() 确定虚拟列是否含有特定值。创建一个 flex 表 (ftest)，填充一些虚拟列和值。为虚拟列 one命名：
=> CREATE FLEX TABLE ftest();
CREATE TABLE
=> copy ftest 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.
>> {"one":1, "two":2}
>> {"one":"one","2":"2"}
>> \.
在 mapcontainsvalue() 映射数据上调用 ftest 。查询对第一个虚拟列返回 false (f) ，对含有值 t的第二个返回 true (one)。
=> SELECT MAPCONTAINSVALUE(__raw__, 'one') FROM ftest;
mapcontainsvalue
------------------
f
t
(2 rows)
返回关于 VMap 中各项目的信息。使用具有一个或多个可选自变量的转换函数访问 VMap 数据中的聚结构值。该函数需要
over() 子句。
MAPITEMS (VMap-data [, passthrough-arg[,...] ])
VMap-data任何 Vmap 数据。Vmap 的存在形式可以是：
Flex 表的 __raw__ 列
从映射函数返回的数据（示例） MAPLOOKUP
其他数据库内容
max_key_length__raw__ 列中，确定函数可以返回的键的最大长度。长度超过
max_key_length 的键会导致查询失败。默认为 VMap 列长度和 65K 中较小的值。max_value_length__raw__ 列中，确定函数可以返回的值的最大长度。大于
max_value_length 的值会导致查询失败。默认为 VMap 列长度和 65K 中较小的值。passthrough-argVMap-data 映射数据中键的一个或多个实参。以下示例说明如何使用带有 over(PARTITION BEST) 子句的 MAPITEMS()。
此示例使用标记为 darkmountain 的 Flex 表确定映射数据中的虚拟列数。使用 count() 函数查询返回映射数据中的虚拟列数：
=> SELECT COUNT(keys) FROM (SELECT MAPITEMS(darkmountain.__raw__) OVER(PARTITION BEST) FROM
darkmountain) AS a;
count
-------
19
(1 row)
下一个示例确定映射数据中存在哪些项：
=> SELECT * FROM (SELECT MAPITEMS(darkmountain.__raw__) OVER(PARTITION BEST) FROM darkmountain) AS a;
keys | values
-------------+---------------
hike_safety | 50.6
name | Mt Washington
type | mountain
height | 17000
hike_safety | 12.2
name | Denali
type | mountain
height | 29029
hike_safety | 34.1
name | Everest
type | mountain
height | 14000
hike_safety | 22.8
name | Kilimanjaro
type | mountain
height | 29029
hike_safety | 15.4
name | Mt St Helens
type | volcano
(19 rows)
以下示例显示如何将返回值的长度限制为 100000：
=> SELECT LENGTH(keys), LENGTH(values) FROM (SELECT MAPITEMS(__raw__ USING PARAMETERS max_value_length=100000) OVER() FROM t1) x;
LENGTH | LENGTH
--------+--------
9 | 98899
(1 row)
在 VMap 中直接查询关键值
查看以下 JSON 输入文件 simple.json。特别注意 three_Array 队列及其四个值：
{
"one": "one",
"two": 2,
"three_Array":
[
"three_One",
"three_Two",
3,
"three_Four"
],
"four": 4,
"five_Map":
{
"five_One": 51,
"five_Two": "Fifty-two",
"five_Three": "fifty three",
"five_Four": 54,
"five_Five": "5 x 5"
},
"six": 6
}
创建 flex 表，映射：
=> CREATE FLEX TABLE mapper();
CREATE TABLE
将 simple.json 载入 flex 表映射：
=> COPY mapper FROM '/home/dbadmin/data/simple.json' parser fjsonparser (flatten_arrays=false,
flatten_maps=false);
Rows Loaded
-------------
1
(1 row)
在 Flex 表的 __raw__ 列上调用 MAPKEYS，查看 Flex 表的键，但不是键子映射。返回值显示 three_Array 是虚拟列之一：
=> SELECT MAPKEYS(__raw__) OVER() FROM mapper;
keys
-------------
five_Map
four
one
six
three_Array
two
(6 rows)
在 Flex 表 mapper 上调用 mapitems，将 three_Array 作为函数的传递实参。调用返回这些队列值：
=> SELECT __identity__, MAPITEMS(three_Array) OVER(PARTITION BY __identity__) FROM mapper;
__identity__ | keys | values
--------------+------+------------
1 | 0 | three_One
1 | 1 | three_Two
1 | 2 | 3
1 | 3 | three_Four
(4 rows)
返回任何 VMap 数据中存在的虚拟列（和值）。此转换函数需要 OVER(PARTITION BEST) 子句。
MAPKEYS (VMap-data)
VMap-data任何 Vmap 数据。Vmap 的存在形式可以是：
Flex 表的 __raw__ 列
从映射函数返回的数据（示例） MAPLOOKUP
其他数据库内容
max_key_length__raw__ 列中，指定函数可以返回的键的最大长度。长度超过
max_key_length 的键会导致查询失败。默认为 VMap 列长度和 65K 中较小的值。确定映射数据的虚拟列数
本例显示如何创建查询，使用 over(PARTITION BEST) 子句和 flex 表、 darkdata ，查找映射数据的虚拟列数。使用 JSON tweet 数据填充表。
=> SELECT COUNT(keys) FROM (SELECT MAPKEYS(darkdata.__raw__) OVER(PARTITION BEST) FROM darkdata) AS a;
count
-------
550
(1 row)
查询映射中所有虚拟列的有序列表
本例显示您查询映射中所有虚拟列的有序列表时，返回数据的片段。
=> SELECT * FROM (SELECT MAPKEYS(darkdata.__raw__) OVER(PARTITION BEST) FROM darkdata) AS a;
keys
-------------------------------------
contributors
coordinates
created_ at
delete.status.id
delete.status.id_str
delete.status.user_id
delete.status.user_id_str
entities.hashtags
entities.media
entities.urls
entities.user_mentions
favorited
geo
id
.
.
.
user.statuses_count
user.time_zone
user.url
user.utc_offset
user.verified
(125 rows)
指定 MAPKEYS 可以返回的键的最大长度
=> SELECT MAPKEYS(__raw__ USING PARAMETERS max_key_length=100000) OVER() FROM mapper;
keys
-------------
five_Map
four
one
six
three_Array
two
(6 rows)
从给定映射中返回虚拟列信息。此转换函数需要 OVER(PARTITION BEST) 子句。
MAPKEYSINFO (VMap-data)
任何 Vmap 数据。Vmap 的存在形式可以是：
Flex 表的 __raw__ 列
从映射函数返回的数据（示例） MAPLOOKUP
其他数据库内容
max_key_length__raw__ 列中，确定函数可以返回的键的最大长度。长度超过
max_key_length 的键会导致查询失败。默认为 VMap 列长度和 65K 中较小的值。此函数是 MAPKEYS() 函数的超集。返回下列关于每个虚拟列的信息：
本例显示您查询映射中所有虚拟列的有序列表时接收到的返回数据的片段。
=> SELECT * FROM (SELECT MAPKEYSINFO(darkdata.__raw__) OVER(PARTITION BEST) FROM darkdata) AS a;
keys | length | type_oid | row_num | field_num
----------------------------------------------------------+--------+----------+---------+-----------
contributors | 0 | 116 | 1 | 0
coordinates | 0 | 116 | 1 | 1
created_at | 30 | 116 | 1 | 2
entities.hashtags | 93 | 199 | 1 | 3
entities.media | 772 | 199 | 1 | 4
entities.urls | 16 | 199 | 1 | 5
entities.user_mentions | 16 | 199 | 1 | 6
favorited | 1 | 116 | 1 | 7
geo | 0 | 116 | 1 | 8
id | 18 | 116 | 1 | 9
id_str | 18 | 116 | 1 | 10
.
.
.
delete.status.id | 18 | 116 | 11 | 0
delete.status.id_str | 18 | 116 | 11 | 1
delete.status.user_id | 9 | 116 | 11 | 2
delete.status.user_id_str | 9 | 116 | 11 | 3
delete.status.id | 18 | 116 | 12 | 0
delete.status.id_str | 18 | 116 | 12 | 1
delete.status.user_id | 9 | 116 | 12 | 2
delete.status.user_id_str | 9 | 116 | 12 | 3
(550 rows)
指定 MAPKEYSINFO 可以返回的键的最大长度
=> SELECT MAPKEYSINFO(__raw__ USING PARAMETERS max_key_length=100000) OVER() FROM mapper;
keys
-------------
five_Map
four
one
six
three_Array
two
(6 rows)
从 VMAP 数据中返回单个键值。如果具有值，此标量函数返回 LONG VARCHAR；如果虚拟列没有值，则返回 NULL。
对于虚拟列名，使用 maplookup 不区分大小写。为了避免加载同名值，请在数据加载时将 fjsonparser 解析器 reject_on_duplicate 参数设置为 true。
通过 fjsonparser 或 favroparser 分析器及其 flatten-arrays 实参加载数据时，您可以控制 VMAP 中非标量值（例如数组）的行为。请参阅 JSON 数据 和 FJSONPARSER 参考。
有关使用 maplookup() 访问嵌套 JSON 数据的信息，请参阅查询嵌套数据。
MAPLOOKUP (VMap-data, 'virtual-column-name' [USING PARAMETERS [case_sensitive={false | true}] [, buffer_size=n] ] )
任何 Vmap 数据。Vmap 的存在形式可以是：
Flex 表的 __raw__ 列
从映射函数返回的数据（示例） MAPLOOKUP
其他数据库内容
buffer_sizebuffer_size) 任何返回值字节数的 =>。所有长度大于 buffer_size 的返回值将被拒绝。
默认值： 0（buffer_size 无限制）
case_sensitive如果键在不同情况下存在，指定是否返回 virtual-column-name 的值。
示例：
(... USING PARAMETERS case_sensitive=true)
默认值： false
此示例返回一个虚拟列 user.location 的值：
=> SELECT MAPLOOKUP(__raw__, 'user.location') FROM darkdata ORDER BY 1;
maplookup
-----------
Chile
Nesnia
Uptown
.
.
chicago
(12 rows)
使用 maplookup buffer_size
使用 buffer_size= 参数表示映射查询为指定虚拟列返回的任何值的最大长度。如果返回键值均不大于 n 字节，则使用该参数分配 n 字节作为 buffer_size。
对于下一个示例，将此 JSON 数据保存到文件 simple_name.json：
{
"name": "sierra",
"age": "63",
"eyes": "brown",
"weapon": "doggie"
}
{
"name": "janis",
"age": "10",
"eyes": "blue",
"weapon": "humor"
}
{
"name": "ben",
"age": "43",
"eyes": "blue",
"weapon": "sword"
}
{
"name": "jen",
"age": "38",
"eyes": "green",
"weapon": "shopping"
}
创建 flex 表 logs。
使用 simple_name.json 将 logs 数据载入 fjsonparser。指定 flatten_arrays 选项作为 True：
=> COPY logs FROM '/home/dbadmin/data/simple_name.json'
PARSER fjsonparser(flatten_arrays=True);
对 maplookup 表的 buffer_size=0 键使用 logs 的 name 。此查询返回所有值：
=> SELECT MAPLOOKUP(__raw__, 'name' USING PARAMETERS buffer_size=0) FROM logs;
MapLookup
-----------
sierra
ben
janis
jen
(4 rows)
接下来，调用 maplookup() 3次，将 buffer_size 参数分别指定为 3、5 和 6。现在，maplookup() 返回字节长度小于或等于 (<=) buffer_size 的值：
=> SELECT MAPLOOKUP(__raw__, 'name' USING PARAMETERS buffer_size=3) FROM logs;
MapLookup
-----------
ben
jen
(4 rows)
=> SELECT MAPLOOKUP(__raw__, 'name' USING PARAMETERS buffer_size=5) FROM logs;
MapLookup
-----------
janis
jen
ben
(4 rows)
=> SELECT MAPLOOKUP(__raw__, 'name' USING PARAMETERS buffer_size=6) FROM logs;
MapLookup
-----------
sierra
janis
jen
ben
(4 rows)
消除空输出行的歧义
此示例展示如何解释空行。如果在没有首先检查密钥是否存在的情况下使用 maplookup，则可能产生歧义。查看下列输出（12 个空行）时，您无法确定 user.location 键是否具有：
非 NULL 值
NULL 值
无值
=> SELECT MAPLOOKUP(__raw__, 'user.location') FROM darkdata;
maplookup
-----------
(12 rows)
消除空输出行，使用 mapcontainskey() 函数和 maplookup()。当 maplookup 返回空字段时，mapcontainskey 的相应值使用 t 表示 NULL 或其他值，或使用 f 表示无值。
以下使用全部两个函数的示例输出将具有 NULL 或名称值的行列为 t，将没有值的行列为 f：
=> SELECT MAPLOOKUP(__raw__, 'user.location'), MAPCONTAINSKEY(__raw__, 'user.location')
FROM darkdata ORDER BY 1;
maplookup | mapcontainskey
-----------+----------------
| t
| t
| t
| t
Chile | t
Nesnia | t
Uptown | t
chicago | t
| f >>>>>>>>>>No value
| f >>>>>>>>>>No value
| f >>>>>>>>>>No value
| f >>>>>>>>>>No value
(12 rows)
检查区分大小写的虚拟列
在键名称不同的情况下，您可以使用具有 maplookup() 参数的 case_sensitive 返回结果。
将下列实例内容保存为 JSON 文件。本例将文件保存为 repeated_key_name.json：
{
"test": "lower1"
}
{
"TEST": "upper1"
}
{
"TEst": "half1"
}
{
"test": "lower2",
"TEst": "half2"
}
{
"TEST": "upper2",
"TEst": "half3"
}
{
"test": "lower3",
"TEST": "upper3"
}
{
"TEst": "half4",
"test": "lower4",
"TEST": "upper4"
}
{
"TesttestTesttestTesttestTesttestTesttestTesttestTesttestTesttestTesttestTesttestTesttestTesttest
TesttestTesttestTesttestTesttest":"1",
"TesttestTesttestTesttestTesttestTesttestTesttestTesttestTesttestTesttestTesttestTesttest
TesttestTesttestTesttestTesttestTest12345":"2"
}
创建 Flex 表 dupe，并加载 JSON 文件：
=> CREATE FLEX TABLE dupe();
CREATE TABLE
dbt=> COPY dupe FROM '/home/release/KData/repeated_key_name.json' parser fjsonparser();
Rows Loaded
-------------
8
(1 row)
接受一个 VMap 和一个或多个键/值对，并返回一个添加了键/值对的新 VMap。键必须使用辅助函数 SetMapKeys() 设置，并且只能是常量字符串。如果 VMap 有任何新的输入键，则原始值将被新的值替换。
MAPPUT (VMap-data, value[,...] USING PARAMETERS keys=SetMapKeys('key'[,...])
VMap-dataFlex 表的 __raw__ 列
从 MAPLOOKUP 等映射函数返回的数据。
其他数据库内容
value[,...]VMap-data 中指定的 VMap 的一个或多个值。keysSetMapKeys() 的结果。 SetMapKeys() 接受一个或多个常量字符串实参。以下示例展示了如何创建 Flex 表并使用 COPY 输入一些基本的 JSON 数据。创建第二个 Flex 表后，插入来自 mapput() 的新 VMap 结果，以及附加的键/值对。
创建样本表：
=> CREATE FLEX TABLE vmapdata1();
CREATE TABLE
从 STDIN 加载样本 JSON 数据：
=> COPY vmapdata1 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.
>> {"aaa": 1, "bbb": 2, "ccc": 3}
>> \.
创建另一个 Flex 表并使用该函数将数据插入其中： => CREATE FLEX TABLE vmapdata2(); => INSERT INTO vmapdata2 SELECT MAPPUT(__raw__, '7','8','9' using parameters keys=SetMapKeys('xxx','yyy','zzz')) from vmapdata1;
查看原始 Flex 表和新 Flex 表之间的差异：
=> SELECT MAPTOSTRING(__raw__) FROM vmapdata1;
maptostring
-----------------------------------------------------
{
"aaa" : "1",
"bbb" : "2",
"ccc" : "3"
}
(1 row)
=> SELECT MAPTOSTRING(__raw__) from vmapdata2;
maptostring
-------------------------------------------------------
{
"mapput" : {
"aaa" : "1",
"bbb" : "2",
"ccc" : "3",
"xxx" : "7",
"yyy" : "8",
"zzz" : "9"
}
}
返回任何 VMap 数据中存在的虚拟列数。使用标量函数确定键的大小。
MAPSIZE (VMap-data)
VMap-data任何 Vmap 数据。Vmap 的存在形式可以是：
Flex 表的 __raw__ 列
从映射函数返回的数据（示例） MAPLOOKUP
其他数据库内容
本例显示从 flex 表 darkmountain 中返回键数的大小：
=> SELECT MAPSIZE(__raw__) FROM darkmountain;
mapsize
---------
3
4
4
4
4
(5 rows)
递归地构建 VMap 数据的字符串表示形式，包括嵌套 JSON 映射。使用此转换函数以 LONG VARCHAR 格式显示 VMap 内容。在使用 MAPVALUES 查询虚拟列之前，您可以使用 MAPTOSTRING 查看映射数据是如何嵌套的。
MAPTOSTRING ( VMap-data [ USING PARAMETERS param=value ] )
VMap-data任何 Vmap 数据。Vmap 的存在形式可以是：
Flex 表的 __raw__ 列
从映射函数返回的数据（示例） MAPLOOKUP
其他数据库内容
canonical_json默认值： true
以下示例使用此表定义和示例数据：
=> CREATE FLEX TABLE darkdata();
CREATE TABLE
=> COPY darkdata 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.
>> {"aaa": 1, "aaa": 2, "AAA": 3, "bbb": "aaa\"bbb"}
>> \.
使用默认值 canonical_json 调用 MAPTOSTRING 仅返回重复键的第一个实例：
=> SELECT MAPTOSTRING (__raw__) FROM darkdata;
maptostring
------------------------------------------------------------
{
"AAA" : "3",
"aaa" : "1",
"bbb" : "aaa\"bbb"
}
(1 row)
canonical_json 设置为 false，函数返回所有键，包括重复键：
=> SELECT MAPTOSTRING(__raw__ using parameters canonical_json=false) FROM darkdata;
maptostring
---------------------------------------------------------------
{
"aaa": "1",
"aaa": "2",
"AAA": "3",
"bbb": "aaa"bbb"
}
(1 row)
返回表示来自 VMap 顶层值的字符串。此转换函数需要 OVER() 子句。
MAPVALUES (VMap-data)
VMap-data任何 Vmap 数据。Vmap 的存在形式可以是：
Flex 表的 __raw__ 列
从映射函数返回的数据（示例） MAPLOOKUP
其他数据库内容
max_value_length__raw__ 列中，指定函数可以返回的值的最大长度。大于
max_value_length 的值会导致查询失败。默认为 VMap 列长度和 65K 中较小的值。下面的例子显示如何使用具有 darkmountain 的 over() 子句查询 over(PARTITION BEST) flex 表（在本例中使用 mapvalues() 子句）。
=> SELECT * FROM (SELECT MAPVALUES(darkmountain.__raw__) OVER(PARTITION BEST) FROM darkmountain) AS a;
values
---------------
29029
34.1
Everest
mountain
29029
15.4
Mt St Helens
volcano
17000
12.2
Denali
mountain
14000
22.8
Kilimanjaro
mountain
50.6
Mt Washington
mountain
(19 rows)
指定 MAPVALUES 可以返回的值的最大长度
=> SELECT MAPVALUES(__raw__ USING PARAMETERS max_value_length=100000) OVER() FROM mapper;
keys
-------------
five_Map
four
one
six
three_Array
two
(6 rows)
返回任何映射数据的版本或无效性。本标量函数返回映射版本（如 1），如果映射数据无效，则返回 -1。
MAPVERSION (VMap-data)
VMap-data任何 Vmap 数据。Vmap 的存在形式可以是：
Flex 表的 __raw__ 列
从映射函数返回的数据（示例） MAPLOOKUP
其他数据库内容
下面的例子显示如何使用 mapversion() 和 darkmountain flex 表，返回 flex 表映射数据的 mapversion 1。
=> SELECT MAPVERSION(__raw__) FROM darkmountain;
mapversion
------------
1
1
1
1
1
(5 rows)