本节中描述的函数以及类函数的表达式都在类型xml
的值上操作。类型xml
的详细信息请参见第 8.13 节。用于在值和类型xml
之间转换的类函数的表达式xmlparse
和xmlserialize
就不在这里重复介绍。使用大部分这些函数要求安装时使用了configure --with-libxml
进行编译。
有一组函数和类函数的表达式可以用来从 SQL 数据产生 XML 内容。它们特别适合于将查询结果格式化成 XML 文档以便于在客户端应用中处理。
xmlcomment
xmlcomment
(text
)
函数xmlcomment
创建了一个 XML 值,它包含一个使用指定文本作为内容的 XML 注释。该文本不包含“--
”或者也不会以一个“-
”结尾,这样结果的结构是一个合法的 XML 注释。如果参数为空,结果也为空。
例子:
SELECT xmlcomment('hello'); xmlcomment -------------- <!--hello-->
xmlconcat
xmlconcat
(xml
[, ...])
函数xmlconcat
将由单个 XML 值组成的列表串接成一个单独的值,这个值包含一个 XML 内容片断。空值会被忽略,只有当没有参数为非空时结果才为空。
例子:
SELECT xmlconcat('<abc/>', '<bar>foo</bar>'); xmlconcat ---------------------- <abc/><bar>foo</bar>
如果 XML 声明存在,它们会按照下面的方式被组合。如果所有的参数值都有相同的 XML 版本声明,该版本将被用在结果中,否则将不使用版本。如果所有参数值有独立声明值“yes”,那么该值将被用在结果中。如果所有参数值都有一个独立声明值并且至少有一个为“no”,则“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/>
xmlelement
xmlelement
(namename
[, xmlattributes(value
[ASattname
] [, ... ])] [, content, ...
])
表达式xmlelement
使用给定名称、属性和内容产生一个 XML 元素。
例子:
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>
不是合法 XML 名字的元素名和属性名将被逃逸,逃逸的方法是将违反的字符用序列_x
替换,其中HHHH
_HHHH
是被替换字符的 Unicode 代码点的十六进制表示。例如:
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 或十六进制编码,具体取决于配置参数xmlbinary的设置。为了将 SQL 和 PostgreSQL 数据类型和 XML 模式声明对齐,我们期待单独数据类型的特定行为能够改进,到那时将会出现一个更为精确的描述。
xmlforest
xmlforest
(content
[ASname
] [, ...])
表达式xmlforest
使用给定名称和内容产生一个元素的 XML 森林(序列)。
例子:
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> ...
如我们在第二个例子中所见,如果内容值是一个列引用,元素名称可以被忽略,这种情况下默认使用列名。否则,必须指定一个名字。
如上文xmlelement
所示,非法 XML 名字的元素名会被逃逸。相似地,内容数据也会被逃逸来产生合法的 XML 内容,除非它已经是一个xml
类型。
注意如果 XML 森林由多于一个元素组成,那么它不是合法的 XML 文档,因此在xmlelement
中包装xmlforest
表达式会有用处。
xmlpi
xmlpi
(nametarget
[,content
])
表达式xmlpi
创建一个 XML 处理指令。如果存在内容,内容不能包含字符序列?>
。
例子:
SELECT xmlpi(name php, 'echo "hello world";'); xmlpi ----------------------------- <?php echo "hello world";?>
xmlroot
xmlroot
(xml
, versiontext
| no value [, standalone yes|no|no value])
表达式xmlroot
修改一个 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>
xmlagg
xmlagg
(xml
)
和这里描述的其他函数不同,函数xmlagg
是一个聚集函数。它将聚集函数调用的输入值串接起来,非常像xmlconcat
所做的事情,除了串接是跨行发生的而不是在单一行的多个表达式上发生。聚集表达式的更多信息请见第 9.20 节。
例子:
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>
这一节描述的表达式检查xml
值的属性。
IS DOCUMENT
xml
IS DOCUMENT
如果参数 XML 值是一个正确的 XML 文档,则IS DOCUMENT
返回真,如果不是则返回假(即它是一个内容片断),或者是参数为空时返回空。文档和内容片断之间的区别请见第 8.13 节。
XMLEXISTS
XMLEXISTS
(text
PASSING [BY REF]xml
[BY REF])
如果第一个参数中的 XPath 表达式返回任何结点,则函数xmlexists
返回真,否则返回假(如果哪一个参数为空,则结果就为空)。
例子:
SELECT xmlexists('//town[text() = ''Toronto'']' PASSING BY REF '<towns><town>Toronto</town><town>Ottawa</town></towns>'); xmlexists ------------ t (1 row)
BY REF
子句在 PostgreSQL 中没有作用,但是为了和其他实现保持 SQL 一致性和兼容性还是允许它出现。每一种 SQL 标准,第一个BY REF
是被要求的,而第二个则是可选的。也要注意 SQL 标准指定xmlexists
结构来将一个 XQuery 表达式作为第一个参数,但 PostgreSQL 目前只支持 XPath,它是 XQuery的一个子集。
xml_is_well_formed
xml_is_well_formed
(text
)xml_is_well_formed_document
(text
)xml_is_well_formed_content
(text
)
这些函数检查一个text
串是不是一个良构的 XML,返回一个布尔结果。xml_is_well_formed_document
检查一个良构的文档,而xml_is_well_formed_content
检查良构的内容。如果xmloption配置参数被设置为DOCUMENT
,xml_is_well_formed
会做第一个函数的工作;如果配置参数被设置为CONTENT
,xml_is_well_formed
会做第二个函数的工作。这意味着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)
最后一个例子显示了这些检查也包括名字空间是否正确地匹配。
要处理数据类型xml
的值, PostgreSQL 提供了函数xpath
和xpath_exists
,它们计算 XPath 1.0 表达式,还有XMLTABLE
表函数。
xpath
xpath
(xpath
,xml
[,nsarray
])
函数xpath
在 XML 值xml
上计算 XPath 表达式xpath
(a text
value)。它返回一个 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)
xpath_exists
xpath_exists
(xpath
,xml
[,nsarray
])
函数xpath_exists
是xpath
函数的一种特殊形式。这个函数不是返回满足 XPath 的单一 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)
xmltable
xmltable
( [XMLNAMESPACES(namespace uri
ASnamespace name
[, ...]), ]row_expression
PASSING [BY REF]document_expression
[BY REF] COLUMNSname
{type
[PATHcolumn_expression
] [DEFAULTdefault_expression
] [NOT NULL | NULL] | FOR ORDINALITY } [, ...] )
xmltable
函数根据给定的XML值、
提取行的XPath过滤器以及一组可选的列定义生成一个表。
可选的XMLNAMESPACES
子句是一个逗号分隔的名称空间列表。
它指定了在文档中使用的XML的名称空间和它们的别名。当前不支持默认的名称空间声明。
所需的row_expression
参数是一个XPath表达式,
该表达式根据提供的XML文档进行评估以获取有序的XML节点序列。
这个顺序是xmltable
转换成输出行的顺序。
document_expression
提供了XML文档进行操作。
BY REF
子句在PostgreSQL中不起作用,
但允许SQL符合性和与其他实现的兼容性。参数必须是格式良好的XML文档;
不接受片段/格式混乱的大量文档。
必需的COLUMNS
子句指定输出表中的字段列表。
如果省略COLUMNS
子句,那么结果集中的行包含一个包含匹配
row_expression
的数据的xml
类型的字段。
如果指定了COLUMNS
,每个项描述一个字段。
格式参阅上面的语法摘要。字段名称和类型都是必需的;路径、默认和是否为空子句是可选的。
一个标记为FOR ORDINALITY
的字段将填充行号,
行号匹配输出行在原始输入XML文档中出现的顺序。
最多只有一个字段可以标记为FOR ORDINALITY
。
一个列的column_expression
是一个XPath表达式,
针对每行计算相对于row_expression
的结果的值,
来找到该列的值。如果没有给出column_expression
,
那么字段名用作隐式路径。
如果一个字段的XPath表达式返回多个元素,则引发一个错误。
如果表达式匹配空标签,结果是一个空字符串(不是NULL
)。
忽略任何xsi:nil
属性。
与column_expression
匹配的XML的文本内容用作字段的值。
一个元素中的多个text()
节点按顺序连接起来。忽略任何子元素、
处理指令和注释,但是子元素的文本内容连接到结果中。请注意,
保留两个非文本元素之间只有空格的text()
节点,
并且不会压缩text()
节点上的前导空白。
如果路径表达式与给定行不匹配,但指定了default_expression
,
则使用评估该表达式得到的值。如果没有为列指定DEFAULT
子句,
则该字段将设置为NULL
。一个default_expression
可能引用列列表中出现在其之前的输出列的值,因此一列的缺省值可能基于另一列的值。
列可能被标记为NOT NULL
。如果NOT NULL
列的
column_expression
不匹配任何内容,并且没有
DEFAULT
或者default_expression
也计算为null,报告错误。
与普通PostgreSQL函数不同,在调用函数之前,column_expression
和default_expression
不会被评估为简单的值。
通常每个输入行对column_expression
进行一次评估,
每当字段需要缺省值时对default_expression
进行评估。
如果表达式符合稳定或不可变,重复评估可能会被忽略。
有效地xmltable
的行为更像是一个子查询而不是函数调用。
这意味着您可以在default_expression
中使用诸如
nextval
之类的易失性函数,并且column_expression
可能依赖于XML文档的其他部分。
示例:
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 bbbCC
以下示例说明了如何使用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)
下面的函数将会把关系表的内容映射成 XML 值。它们可以被看成是 XML 导出功能:
table_to_xml(tbl regclass, nulls boolean, tableforest boolean, targetns text) query_to_xml(query text, nulls boolean, tableforest boolean, targetns text) cursor_to_xml(cursor refcursor, count int, nulls boolean, tableforest boolean, targetns text)
每一个函数的返回值都是xml
。
table_to_xml
映射由参数tbl
传递的命名表的内容。regclass
类型接受使用常见标记标识表的字符串,包括可选的模式限定和双引号。query_to_xml
执行由参数query
传递的查询并且映射结果集。cursor_to_xml
从cursor
指定的游标中取出指定数量的行。如果需要映射一个大型的表,我们推荐这种变体,因为每一个函数都是在内存中构建结果值的。
如果tableforest
为假,则结果的 XML 文档看起来像这样:
<tablename> <row> <columnname1>data</columnname1> <columnname2>data</columnname2> </row> <row> ... </row> ... </tablename>
如果tableforest
为真,结果是一个看起来像这样的 XML 内容片断:
<tablename> <columnname1>data</columnname1> <columnname2>data</columnname2> </tablename> <tablename> ... </tablename> ...
如果没有表名可用,在映射一个查询或一个游标时,在第一种格式中使用串table
,在第二种格式中使用row
。
这几种格式的选择由用户决定。第一种格式是一个正确的 XML 文档,它在很多应用中都很重要。如果结果值要被重组为一个文档,第二种格式在cursor_to_xml
函数中更有用。前文讨论的产生 XML 内容的函数(特别是xmlelement
)可以被用来把结果修改成符合用户的要求。
数据值会被以前文的函数xmlelement
中描述的相同方法映射。
参数nulls
决定空值是否会被包含在输出中。如果为真,列中的空值被表示为:
<columnname xsi:nil="true"/>
其中xsi
是 XML 模式实例的 XML 名字空间前缀。一个合适的名字空间声明将被加入到结果值中。如果为假,包含空值的列将被从输出中忽略掉。
参数targetns
指定想要的结果的 XML 名字空间。如果没有想要的特定名字空间,将会传递一个空串。
下面的函数返回 XML 模式文档,这些文档描述上述对应函数所执行的映射:
table_to_xmlschema(tbl regclass, nulls boolean, tableforest boolean, targetns text) query_to_xmlschema(query text, nulls boolean, tableforest boolean, targetns text) cursor_to_xmlschema(cursor refcursor, nulls boolean, tableforest boolean, targetns text)
最重要的是相同的参数被传递来获得匹配的 XML 数据映射和 XML 模式文档。
下面的函数产生 XML 数据映射和对应的 XML 模式,并把产生的结果链接在一起放在一个文档(或森林)中。在要求自包含和自描述的结果是它们非常有用:
table_to_xml_and_xmlschema(tbl regclass, nulls boolean, tableforest boolean, targetns text) query_to_xml_and_xmlschema(query text, nulls boolean, tableforest boolean, targetns text)
另外,下面的函数可用于产生相似的整个模式或整个当前数据库的映射:
schema_to_xml(schema name, nulls boolean, tableforest boolean, targetns text) schema_to_xmlschema(schema name, nulls boolean, tableforest boolean, targetns text) schema_to_xml_and_xmlschema(schema name, nulls boolean, tableforest boolean, targetns text) database_to_xml(nulls boolean, tableforest boolean, targetns text) database_to_xmlschema(nulls boolean, tableforest boolean, targetns text) database_to_xml_and_xmlschema(nulls boolean, tableforest boolean, targetns text)
注意这些函数可能产生很多数据,它们都需要在内存中被构建。在请求大型模式或数据库的内容映射时,可以考虑分别映射每一个表,甚至通过一个游标来映射。
一个模式内容映射的结果看起来像这样:
<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>