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)