登录9.15. XML 函数#
本节中描述的函数和类函数表达式对xml类型的数值进行操作。有关xml类型的详细信息，请参见第 8.13 节。类函数表达式xmlparse和xmlserialize用于转换到xml类型和从xml类型转换，它们在此处未记录，而是在该节中记录。
要使用这些函数中的大多数，需要使用configure --with-libxml构建PostgreSQL。
9.15.1. 生成 XML 内容#
提供了一组函数和类函数表达式，用于从 SQL 数据生成 XML 内容。因此，它们特别适合将查询结果格式化为 XML 文档，以便在客户端应用程序中进行处理。
9.15.1.1.xmlcomment#
xmlcomment ( text ) → xml函数xmlcomment创建一个 XML 值，其中包含一个 XML 注释，其文本为指定内容。文本不能包含“--”或以“-”结尾，否则生成的结构将不是有效的 XML 注释。如果参数为 null，则结果为 null。
示例
SELECT xmlcomment('hello');
xmlcomment
--------------
<!--hello-->9.15.1.2.xmlconcat#
xmlconcat ( xml [, ...] ) → xml函数xmlconcat连接一系列单独的 XML 值，以创建一个包含 XML 内容片段的单个值。Null 值将被忽略；仅当没有非空参数时，结果才为 null。
示例
SELECT xmlconcat('<abc/>', '<bar>foo</bar>');
xmlconcat
----------------------
<abc/><bar>foo</bar>如果存在 XML 声明，则按如下方式进行组合。如果所有参数值具有相同的 XML 版本声明，则在结果中使用该版本，否则不使用版本。如果所有参数值具有独立声明值“yes”，则在结果中使用该值。如果所有参数值具有独立声明值，并且至少有一个为“no”，则在结果中使用该值。否则，结果将没有独立声明。如果确定结果需要独立声明但不需要版本声明，则将使用版本 1.0 的版本声明，因为 XML 要求 XML 声明包含版本声明。在所有情况下，编码声明都将被忽略并删除。
示例
SELECT xmlconcat('<?xml version="1.1"?><foo/>', '<?xml version="1.1" standalone="no"?><bar/>');
xmlconcat
-----------------------------------
<?xml version="1.1"?><foo/><bar/>9.15.1.3.xmlelement#
xmlelement ( NAME name [, XMLATTRIBUTES ( attvalue [ AS attname ] [, ...] ) ] [, content [, ...]] ) → xml表达式xmlelement生成一个具有给定名称、属性和内容的 XML 元素。语法中显示的*name和attname项是简单的标识符，而不是值。attvalue和content项是表达式，可以生成任何PostgreSQL数据类型。XMLATTRIBUTES中的参数生成 XML 元素的属性；content*值连接起来形成其内容。
示例
text
SELECT xmlelement(name foo);
xmlelement
------------
<foo/>
SELECT xmlelement(name foo, xmlattributes('xyz' as bar));
xmlelement
------------------
<foo bar="xyz"/>
SELECT xmlelement(name foo, xmlattributes(current_date as bar), 'cont', 'ent');
xmlelement
-------------------------------------
<foo bar="2007-01-26">content</foo>通过将违规字符替换为序列_x*HHHH*_来转义不是有效 XML 名称的元素和属性名称，其中*HHHH*是字符的 Unicode 代码点，采用十六进制表示法。例如
text
SELECT xmlelement(name "foo$bar", xmlattributes('xyz' as "a&b"));
xmlelement
----------------------------------
<foo_x0024_bar a_x0026_b="xyz"/>如果属性值为列引用，则不必指定显式属性名称，在这种情况下，列的名称将默认用作属性名称。在其他情况下，必须为属性指定一个显式名称。因此，此示例有效
CREATE TABLE test (a xml, b xml);
SELECT xmlelement(name test, xmlattributes(a, b)) FROM test;但这些不是
SELECT xmlelement(name test, xmlattributes('constant'), a, b) FROM test;
SELECT xmlelement(name test, xmlattributes(func(a, b))) FROM test;如果指定了元素内容，将根据其数据类型进行格式化。如果内容本身为xml类型，则可以构造复杂的 XML 文档。例如
SELECT xmlelement(name foo, xmlattributes('xyz' as bar),
xmlelement(name abc),
xmlcomment('test'),
xmlelement(name xyz));
xmlelement
----------------------------------------------
<foo bar="xyz"><abc/><!--test--><xyz/></foo>其他类型的将被格式化为有效的 XML 字符数据。这意味着特别是字符 <、> 和 & 将被转换为实体。二进制数据（数据类型bytea）将以 base64 或 hex 编码表示，具体取决于配置参数xmlbinary的设置。各个数据类型的特定行为预计会演变，以便将 PostgreSQL 映射与 SQL:2006 及更高版本中指定的映射对齐，如第 D.3.1.3 节中所述。
9.15.1.4.xmlforest#
xmlforest ( content [ AS name ] [, ...] ) → xmlxmlforest表达式使用给定的名称和内容生成元素的 XML 林（序列）。对于xmlelement，每个*name必须是一个简单标识符，而content*表达式可以具有任何数据类型。
示例
text
SELECT xmlforest('abc' AS foo, 123 AS bar);
xmlforest
------------------------------
<foo>abc</foo><bar>123</bar>
SELECT xmlforest(table_name, column_name)
FROM information_schema.columns
WHERE table_schema = 'pg_catalog';
xmlforest
-----------------------------------------------------------------------
<table_name>pg_authid</table_name><column_name>rolname</column_name>
<table_name>pg_authid</table_name><column_name>rolsuper</column_name>
...如第二个示例中所示，如果内容值是列引用，则可以省略元素名称，在这种情况下，默认使用列名称。否则，必须指定一个名称。
不是有效 XML 名称的元素名称将按上面xmlelement所示进行转义。类似地，内容数据将被转义为有效的 XML 内容，除非它已经是xml类型。
请注意，如果 XML 林包含多个元素，则它们不是有效的 XML 文档，因此将xmlforest表达式包装在xmlelement中可能很有用。
9.15.1.5.xmlpi#
xmlpi ( NAME name [, content ] ) → xmlxmlpi`表达式创建一个 XML 处理指令。对于xmlelement，*name*必须是一个简单的标识符，而*content*表达式可以具有任何数据类型。如果存在，*content*不得包含字符序列``>。
示例
SELECT xmlpi(name php, 'echo "hello world";');
xmlpi
-----------------------------
<?php echo "hello world";?>9.15.1.6.``xmlroot[#](#FUNCTIONS-PRODUCING-XML-XMLROOT)
xmlroot ( xml, VERSION {text|NO VALUE} [, STANDALONE {YES|NO|NO VALUE} ] ) → xmlxmlroot表达式更改 XML 值根节点的属性。如果指定了版本，它将替换根节点版本声明中的值；如果指定了独立设置，它将替换根节点独立声明中的值。
SELECT xmlroot(xmlparse(document '<?xml version="1.1"?><content>abc</content>'),
version '1.0', standalone yes);
xmlroot
----------------------------------------
<?xml version="1.0" standalone="yes"?>
<content>abc</content>9.15.1.7.``xmlagg[#](#FUNCTIONS-XML-XMLAGG)
xmlagg ( xml ) → xml与此处描述的其他函数不同，函数xmlagg`是一个聚合函数。它将输入值连接到聚合函数调用中，很像xmlconcat`所做的那样，只不过连接发生在行之间，而不是单行中的表达式之间。有关聚合函数的更多信息，请参见第 9.21 节。
示例
CREATE TABLE test (y int, x xml);
INSERT INTO test VALUES (1, '<foo>abc</foo>');
INSERT INTO test VALUES (2, '<bar/>');
SELECT xmlagg(x) FROM test;
xmlagg
----------------------
<foo>abc</foo><bar/>为了确定连接的顺序，可以向聚合调用中添加``ORDER BY`子句，如第 4.2.7 节中所述。例如
SELECT xmlagg(x ORDER BY y DESC) FROM test;
xmlagg
----------------------
<bar/><foo>abc</foo>以下非标准方法过去在以前的版本中被推荐，在特定情况下可能仍然有用
SELECT xmlagg(x) FROM (SELECT * FROM test ORDER BY y DESC) AS tab;
xmlagg
----------------------
<bar/><foo>abc</foo>9.15.2. XML 谓词#
本节中描述的表达式检查``xml`值的属性。
9.15.2.1.``IS DOCUMENT[#](#FUNCTIONS-PRODUCING-XML-IS-DOCUMENT)
xml IS DOCUMENT → boolean如果参数 XML 值是正确的 XML 文档，则表达式``IS DOCUMENT`返回 true；如果它不是（即它是一个内容片段），则返回 false；如果参数为 null，则返回 null。有关文档和内容片段之间的差异，请参见第 8.13 节。
9.15.2.2.``IS NOT DOCUMENT[#](#FUNCTIONS-PRODUCING-XML-IS-NOT-DOCUMENT)
xml IS NOT DOCUMENT → boolean如果参数 XML 值是正确的 XML 文档，则表达式``IS NOT DOCUMENT`返回 false；如果它不是（即它是一个内容片段），则返回 true；如果参数为 null，则返回 null。
9.15.2.3.``XMLEXISTS[#](#XML-EXISTS)
XMLEXISTS ( text PASSING [BY {REF|VALUE}] xml [BY {REF|VALUE}] ) → boolean函数xmlexists评估 XPath 1.0 表达式（第一个参数），并以传递的 XML 值作为其上下文项。如果评估结果产生一个空节点集，则该函数返回 false；如果产生任何其他值，则返回 true。如果任何参数为 null，则该函数返回 null。作为上下文项传递的非 null 值必须是 XML 文档，而不是内容片段或任何非 XML 值。
示例
SELECT xmlexists('//town[text() = ''Toronto'']' PASSING BY VALUE '<towns><town>Toronto</town><town>Ottawa</town></towns>');
xmlexists
------------
t
(1 row)在PostgreSQL中接受BY REF和BY VALUE子句，但会忽略它们，如第 D.3.2 节所述。
在 SQL 标准中，xmlexists函数在 XML 查询语言中评估表达式，但PostgreSQL仅允许 XPath 1.0 表达式，如第 D.3.1 节所述。
9.15.2.4.xml_is_well_formed#
xml_is_well_formed ( text ) → boolean
xml_is_well_formed_document ( text ) → boolean
xml_is_well_formed_content ( text ) → boolean这些函数检查text字符串是否表示格式良好的 XML，并返回布尔结果。xml_is_well_formed_document检查格式良好的文档，而xml_is_well_formed_content检查格式良好的内容。xml_is_well_formed在xmloption配置参数设置为DOCUMENT时执行前者，或在设置为CONTENT时执行后者。这意味着xml_is_well_formed用于查看是否可以成功简单地强制转换为类型xml，而其他两个函数用于查看是否可以成功执行XMLPARSE的相应变体。
示例
SET xmloption TO DOCUMENT;
SELECT xml_is_well_formed('<>');
xml_is_well_formed
--------------------
f
(1 row)
SELECT xml_is_well_formed('<abc/>');
xml_is_well_formed
--------------------
t
(1 row)
SET xmloption TO CONTENT;
SELECT xml_is_well_formed('abc');
xml_is_well_formed
--------------------
t
(1 row)
SELECT xml_is_well_formed_document('<pg:foo xmlns:pg="http://postgresql.org/stuff">bar</pg:foo>');
xml_is_well_formed_document
-----------------------------
t
(1 row)
SELECT xml_is_well_formed_document('<pg:foo xmlns:pg="http://postgresql.org/stuff">bar</my:foo>');
xml_is_well_formed_document
-----------------------------
f
(1 row)最后一个示例显示检查包括是否正确匹配命名空间。
9.15.3. 处理 XML#
为了处理数据类型为xml的值，PostgreSQL 提供了函数xpath和xpath_exists，它们评估 XPath 1.0 表达式，以及XMLTABLE表函数。
9.15.3.1.xpath#
xpath ( xpath text, xml xml [, nsarray text[] ] ) → xml[]函数xpath针对 XML 值*xml评估 XPath 1.0 表达式xpath*（作为文本提供）。它返回一个 XML 值数组，对应于 XPath 表达式生成的节点集。如果 XPath 表达式返回标量值而不是节点集，则返回一个单元素数组。
第二个参数必须是格式良好的 XML 文档。特别是，它必须具有单个根节点元素。
函数的可选第三个参数是命名空间映射的数组。该数组应为二维text数组，其中第二轴的长度等于 2（即，它应为数组的数组，每个数组恰好包含 2 个元素）。每个数组条目的第一个元素是命名空间名称（别名），第二个元素是命名空间 URI。不需要此数组中提供的别名与 XML 文档本身中使用的别名相同（换句话说，在 XML 文档和xpath函数上下文中，别名都是局部）。
示例
SELECT xpath('/my:a/text()', '<my:a xmlns:my="http://example.com">test</my:a>',
ARRAY[ARRAY['my', 'http://example.com']]);
xpath
--------
{test}
(1 row)要处理默认（匿名）命名空间，请执行类似以下操作
SELECT xpath('//mydefns:b/text()', '<a xmlns="http://example.com"><b>test</b></a>',
ARRAY[ARRAY['mydefns', 'http://example.com']]);
xpath
--------
{test}
(1 row)9.15.3.2.xpath_exists#
xpath_exists ( xpath text, xml xml [, nsarray text[] ] ) → boolean函数xpath_exists是xpath函数的专门形式。此函数不会返回满足 XPath 1.0 表达式的各个 XML 值，而是返回一个布尔值，指示查询是否得到满足（具体来说，是否产生了除空节点集之外的任何值）。此函数等效于XMLEXISTS谓词，不同之处在于它还支持命名空间映射参数。
示例
SELECT xpath_exists('/my:a/text()', '<my:a xmlns:my="http://example.com">test</my:a>',
ARRAY[ARRAY['my', 'http://example.com']]);
xpath_exists
--------------
t
(1 row)9.15.3.3.xmltable#
XMLTABLE (
[ XMLNAMESPACES ( namespace_uri AS namespace_name [, ...] ), ]
row_expression PASSING [BY {REF|VALUE}] document_expression [BY {REF|VALUE}]
COLUMNS name { type [PATH column_expression] [DEFAULT default_expression] [NOT NULL | NULL]
| FOR ORDINALITY }
[, ...]
) → setof recordxmltable表达式基于 XML 值、用于提取行的 XPath 筛选器和一组列定义生成一个表。虽然它在语法上类似于函数，但它只能作为查询的FROM子句中的表出现。
可选的XMLNAMESPACES子句给出了一个逗号分隔的命名空间定义列表，其中每个*namespace_uri都是text表达式，每个namespace_name*都是一个简单标识符。它指定文档中使用的 XML 命名空间及其别名。目前不支持默认命名空间规范。
必需的*row_expression参数是一个 XPath 1.0 表达式（以text给出），它经过评估，将 XML 值document_expression作为其上下文项传递，以获取一组 XML 节点。这些节点是xmltable转换为输出行的内容。如果document_expression为 null，或者如果row_expression*产生一个空节点集或除节点集之外的任何值，则不会产生任何行。
*document_expression为row_expression*提供上下文项。它必须是一个格式良好的 XML 文档；不接受片段/林。如第 D.3.2 节中所述，接受BY REF和BY VALUE子句，但会忽略它们。
在 SQL 标准中，xmltable函数评估 XML 查询语言中的表达式，但PostgreSQL只允许 XPath 1.0 表达式，如第 D.3.1 节所述。
必需的COLUMNS子句指定将在输出表中生成的列。有关格式，请参见上面的语法摘要。每个列都需要一个名称，还需要一个数据类型（除非指定了FOR ORDINALITY，在这种情况下，类型integer是隐式的）。路径、默认值和可空性子句是可选的。
标记为FOR ORDINALITY的列将使用行号填充，从 1 开始，按照从*row_expression*的结果节点集检索到的节点的顺序。最多可以将一列标记为FOR ORDINALITY。
注意
XPath 1.0 未指定节点集中节点的顺序，因此依赖于结果特定顺序的代码将取决于实现。可以在第 D.3.1.2 节中找到详细信息。
一列的*column_expression是 XPath 1.0 表达式，它针对每一行进行评估，其中row_expression结果作为其上下文项的当前节点，以查找该列的值。如果没有给出column_expression*，则列名将用作隐式路径。
如果一列的 XPath 表达式返回非 XML 值（在 XPath 1.0 中仅限于字符串、布尔值或双精度），并且该列的 PostgreSQL 类型不是xml，则该列将被设置为好像通过将该值的字符串表示形式分配给 PostgreSQL 类型一样。（如果该值是布尔值，则其字符串表示形式将被视为1或0，如果输出列的类型类别是数字，否则为true或false。）
如果一列的 XPath 表达式返回一组非空 XML 节点，并且该列的 PostgreSQL 类型是xml，则该列将被准确地分配表达式结果，如果它是文档或内容形式。[8]
分配给xml输出列的非 XML 结果会生成内容，一个包含结果字符串值的文本节点。分配给任何其他类型的列的 XML 结果不能有多个节点，否则会引发错误。如果恰好有一个节点，则该列将被设置为好像通过将该节点的字符串值（如 XPath 1.0string函数所定义）分配给 PostgreSQL 类型一样。
XML 元素的字符串值是该元素及其后代中包含的所有文本节点按文档顺序连接的结果。没有后代文本节点的元素的字符串值为空字符串（不是NULL）。将忽略所有xsi:nil属性。请注意，两个非文本元素之间的仅包含空白的text()节点将被保留，并且text()节点上的前导空白不会被展平。可以参考 XPath 1.0string函数了解定义其他 XML 节点类型和非 XML 值的字符串值的规则。
此处介绍的转换规则并非完全符合 SQL 标准，如第 D.3.1.3 节所述。
如果路径表达式对给定行返回一个空节点集（通常在不匹配时），则该列将被设置为NULL，除非指定了*default_expression*；然后使用评估该表达式得到的值。
在调用xmltable时，*default_expression不会立即被评估，而是在每次需要为该列指定默认值时被评估。如果表达式符合稳定或不可变的条件，则可以跳过重复评估。这意味着你可以在default_expression*中使用易失函数，如nextval。
可以将列标记为NOT NULL。如果NOT NULL列的*column_expression与任何内容都不匹配，并且没有DEFAULT或default_expression*也评估为 null，则会报告一个错误。
示例
CREATE TABLE xmldata AS SELECT
xml $$
<ROWS>
<ROW id="1">
<COUNTRY_ID>AU</COUNTRY_ID>
<COUNTRY_NAME>Australia</COUNTRY_NAME>
</ROW>
<ROW id="5">
<COUNTRY_ID>JP</COUNTRY_ID>
<COUNTRY_NAME>Japan</COUNTRY_NAME>
<PREMIER_NAME>Shinzo Abe</PREMIER_NAME>
<SIZE unit="sq_mi">145935</SIZE>
</ROW>
<ROW id="6">
<COUNTRY_ID>SG</COUNTRY_ID>
<COUNTRY_NAME>Singapore</COUNTRY_NAME>
<SIZE unit="sq_km">697</SIZE>
</ROW>
</ROWS>
$$ AS data;
SELECT xmltable.*
FROM xmldata,
XMLTABLE('//ROWS/ROW'
PASSING data
COLUMNS id int PATH '@id',
ordinality FOR ORDINALITY,
"COUNTRY_NAME" text,
country_id text PATH 'COUNTRY_ID',
size_sq_km float PATH 'SIZE[@unit = "sq_km"]',
size_other text PATH
'concat(SIZE[@unit!="sq_km"], " ", SIZE[@unit!="sq_km"]/@unit)',
premier_name text PATH 'PREMIER_NAME' DEFAULT 'not specified');
id | ordinality | COUNTRY_NAME | country_id | size_sq_km | size_other | premier_name
----+------------+--------------+------------+------------+--------------+---------------
1 | 1 | Australia | AU | | | not specified
5 | 2 | Japan | JP | | 145935 sq_mi | Shinzo Abe
6 | 3 | Singapore | SG | 697 | | not specified以下示例展示了多个 text() 节点的连接、列名作为 XPath 过滤器的用法，以及空白、XML 注释和处理指令的处理方式
CREATE TABLE xmlelements AS SELECT
xml $$
<root>
<element> Hello<!-- xyxxz -->2a2<?aaaaa?> <!--x--> bbb<x>xxx</x>CC </element>
</root>
$$ AS data;
SELECT xmltable.*
FROM xmlelements, XMLTABLE('/root' PASSING data COLUMNS element text);
element
-------------------------
Hello2a2 bbbxxxCC以下示例说明了如何使用XMLNAMESPACES子句指定 XML 文档和 XPath 表达式中使用的命名空间列表
WITH xmldata(data) AS (VALUES ('
<example xmlns="http://example.com/myns" xmlns:B="http://example.com/b">
<item foo="1" B:bar="2"/>
<item foo="3" B:bar="4"/>
<item foo="4" B:bar="5"/>
</example>'::xml)
)
SELECT xmltable.*
FROM XMLTABLE(XMLNAMESPACES('http://example.com/myns' AS x,
'http://example.com/b' AS "B"),
'/x:example/x:item'
PASSING (SELECT data FROM xmldata)
COLUMNS foo int PATH '@foo',
bar int PATH '@B:bar');
foo | bar
-----+-----
1 | 2
3 | 4
4 | 5
(3 rows)9.15.4. 将表映射到 XML#
以下函数将关系表的内容映射到 XML 值。可以将它们视为 XML 导出功能
table_to_xml ( table regclass, nulls boolean,
tableforest boolean, targetns text ) → xml
query_to_xml ( query text, nulls boolean,
tableforest boolean, targetns text ) → xml
cursor_to_xml ( cursor refcursor, count integer, nulls boolean,
tableforest boolean, targetns text ) → xmltable_to_xml映射作为参数*table传递的命名表的内容。regclass类型接受使用通常表示法（包括可选架构限定和双引号）标识表的字符串（有关详细信息，请参见第 8.19 节）。query_to_xml执行文本作为参数query传递的查询并映射结果集。cursor_to_xml从参数cursor*指定的游标中获取指定数量的行。如果必须映射大型表，则建议使用此变体，因为结果值是由每个函数在内存中构建的。
如果*tableforest*为 false，则生成的 XML 文档如下所示
<tablename>
<row>
<columnname1>data</columnname1>
<columnname2>data</columnname2>
</row>
<row>
...
</row>
...
</tablename>如果*tableforest*为 true，则结果是一个 XML 内容片段，如下所示
<tablename>
<columnname1>data</columnname1>
<columnname2>data</columnname2>
</tablename>
<tablename>
...
</tablename>如果表名不可用，即映射查询或游标时，字符串table用于第一种格式，row用于第二种格式。
这些格式之间的选择取决于用户。第一种格式是一个正确的 XML 文档，这在许多应用程序中很重要。如果结果值稍后要重新组装到一个文档中，则第二种格式在cursor_to_xml函数中往往更有用。上面讨论的用于生成 XML 内容的函数，特别是xmlelement，可用于根据需要更改结果。
数据值以与上面xmlelement函数所述相同的方式映射。
参数*nulls*确定是否应在输出中包含空值。如果为 true，则列中的空值表示为
<columnname xsi:nil="true"/>其中xsi是 XML 模式实例的 XML 命名空间前缀。适当的命名空间声明将添加到结果值中。如果为 false，则包含空值的列将从输出中简单地省略。
参数*targetns*指定结果的所需 XML 命名空间。如果不希望特定命名空间，则应传递一个空字符串。
以下函数返回 XML 模式文档，描述上面相应函数执行的映射
table_to_xmlschema ( table regclass, nulls boolean,
tableforest boolean, targetns text ) → xml
query_to_xmlschema ( query text, nulls boolean,
tableforest boolean, targetns text ) → xml
cursor_to_xmlschema ( cursor refcursor, nulls boolean,
tableforest boolean, targetns text ) → xml必须传递相同参数才能获得匹配的 XML 数据映射和 XML 模式文档。
以下函数在一个文档（或林）中生成 XML 数据映射和相应的 XML 模式，并将其链接在一起。它们在需要自包含和自描述的结果时很有用
table_to_xml_and_xmlschema ( table regclass, nulls boolean,
tableforest boolean, targetns text ) → xml
query_to_xml_and_xmlschema ( query text, nulls boolean,
tableforest boolean, targetns text ) → xml此外，以下函数可用于生成整个模式或整个当前数据库的类似映射
schema_to_xml ( schema name, nulls boolean,
tableforest boolean, targetns text ) → xml
schema_to_xmlschema ( schema name, nulls boolean,
tableforest boolean, targetns text ) → xml
schema_to_xml_and_xmlschema ( schema name, nulls boolean,
tableforest boolean, targetns text ) → xml
database_to_xml ( nulls boolean,
tableforest boolean, targetns text ) → xml
database_to_xmlschema ( nulls boolean,
tableforest boolean, targetns text ) → xml
database_to_xml_and_xmlschema ( nulls boolean,
tableforest boolean, targetns text ) → xml这些函数忽略当前用户不可读的表。数据库范围的函数还忽略当前用户没有USAGE（查找）权限的模式。
请注意，这些函数可能会产生大量数据，需要在内存中构建。在请求大型模式或数据库的内容映射时，可能值得考虑分别映射表，甚至可以通过游标映射表。
模式内容映射的结果如下所示
<schemaname>
table1-mapping
table2-mapping
...
</schemaname>其中表映射的格式取决于*tableforest*参数，如上所述。
数据库内容映射的结果如下所示
<dbname>
<schema1name>
...
</schema1name>
<schema2name>
...
</schema2name>
...
</dbname>其中模式映射如上所述。
作为使用这些函数产生的输出的示例，示例 9.1展示了一个 XSLT 样式表，它将table_to_xml_and_xmlschema的输出转换为包含表格形式表数据的 HTML 文档。以类似的方式，可以将这些函数的结果转换为其他基于 XML 的格式。
示例 9.1。用于将 SQL/XML 输出转换为 HTML 的 XSLT 样式表
<?xml version="1.0"?>
<xsl:stylesheet version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns="http://www.w3.org/1999/xhtml"
>
<xsl:output method="xml"
doctype-system="http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"
doctype-public="-//W3C/DTD XHTML 1.0 Strict//EN"
indent="yes"/>
<xsl:template match="/*">
<xsl:variable name="schema" select="//xsd:schema"/>
<xsl:variable name="tabletypename"
select="$schema/xsd:element[@name=name(current())]/@type"/>
<xsl:variable name="rowtypename"
select="$schema/xsd:complexType[@name=$tabletypename]/xsd:sequence/xsd:element[@name='row']/@type"/>
<html>
<head>
<title><xsl:value-of select="name(current())"/></title>
</head>
<body>
<table>
<tr>
<xsl:for-each select="$schema/xsd:complexType[@name=$rowtypename]/xsd:sequence/xsd:element/@name">
<th><xsl:value-of select="."/></th>
</xsl:for-each>
</tr>
<xsl:for-each select="row">
<tr>
<xsl:for-each select="*">
<td><xsl:value-of select="."/></td>
</xsl:for-each>
</tr>
</xsl:for-each>
</table>
</body>
</html>
</xsl:template>
</xsl:stylesheet>[8]顶层包含多个元素节点或元素外部的非空白文本的结果是内容形式的示例。XPath 结果可以不是任何形式，例如，如果它返回从包含它的元素中选择的属性节点。此类结果将被放入内容形式，每个此类不允许的节点都将替换为其字符串值，如 XPath 1.0string函数所定义。