Baoding-FenShuaJiang
/
Green_GoodERP18_FSJ_Standard
Watch 1
Star 0
Wiki 捐赠
gooderp18绿色标准版
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Tree: 0f75e31513
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '0f75e31513'
${ noResults }
Green_GoodERP18_FSJ_Standard/PostgreSQL/doc/postgresql/html/functions-xml.html

868 lines
47KB
Raw Blame History 

  1. <?xml version="1.0" encoding="UTF-8" standalone="no"?>

  2. <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /><title>9.14. XML Functions</title><link rel="stylesheet" type="text/css" href="stylesheet.css" /><link rev="made" href="pgsql-docs@lists.postgresql.org" /><meta name="generator" content="DocBook XSL Stylesheets V1.79.1" /><link rel="prev" href="functions-textsearch.html" title="9.13. Text Search Functions and Operators" /><link rel="next" href="functions-json.html" title="9.15. JSON Functions and Operators" /></head><body><div xmlns="http://www.w3.org/TR/xhtml1/transitional" class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="5" align="center">9.14. XML Functions</th></tr><tr><td width="10%" align="left"><a accesskey="p" href="functions-textsearch.html" title="9.13. Text Search Functions and Operators">Prev</a> </td><td width="10%" align="left"><a accesskey="u" href="functions.html" title="Chapter 9. Functions and Operators">Up</a></td><th width="60%" align="center">Chapter 9. Functions and Operators</th><td width="10%" align="right"><a accesskey="h" href="index.html" title="PostgreSQL 12.4 Documentation">Home</a></td><td width="10%" align="right"> <a accesskey="n" href="functions-json.html" title="9.15. JSON Functions and Operators">Next</a></td></tr></table><hr></hr></div><div class="sect1" id="FUNCTIONS-XML"><div class="titlepage"><div><div><h2 class="title" style="clear: both">9.14. XML Functions</h2></div></div></div><div class="toc"><dl class="toc"><dt><span class="sect2"><a href="functions-xml.html#FUNCTIONS-PRODUCING-XML">9.14.1. Producing XML Content</a></span></dt><dt><span class="sect2"><a href="functions-xml.html#FUNCTIONS-XML-PREDICATES">9.14.2. XML Predicates</a></span></dt><dt><span class="sect2"><a href="functions-xml.html#FUNCTIONS-XML-PROCESSING">9.14.3. Processing XML</a></span></dt><dt><span class="sect2"><a href="functions-xml.html#FUNCTIONS-XML-MAPPING">9.14.4. Mapping Tables to XML</a></span></dt></dl></div><a id="id-1.5.8.19.2" class="indexterm"></a><p>

  3.    The functions and function-like expressions described in this

  4.    section operate on values of type <code class="type">xml</code>.  See <a class="xref" href="datatype-xml.html" title="8.13. XML Type">Section 8.13</a> for information about the <code class="type">xml</code>

  5.    type.  The function-like expressions <code class="function">xmlparse</code>

  6.    and <code class="function">xmlserialize</code> for converting to and from

  7.    type <code class="type">xml</code> are documented there, not in this section.

  8.   </p><p>

  9.    Use of most of these functions

  10.    requires <span class="productname">PostgreSQL</span> to have been built

  11.    with <code class="command">configure --with-libxml</code>.

  12.   </p><div class="sect2" id="FUNCTIONS-PRODUCING-XML"><div class="titlepage"><div><div><h3 class="title">9.14.1. Producing XML Content</h3></div></div></div><p>

  13.     A set of functions and function-like expressions are available for

  14.     producing XML content from SQL data.  As such, they are

  15.     particularly suitable for formatting query results into XML

  16.     documents for processing in client applications.

  17.    </p><div class="sect3" id="id-1.5.8.19.5.3"><div class="titlepage"><div><div><h4 class="title">9.14.1.1. <code class="literal">xmlcomment</code></h4></div></div></div><a id="id-1.5.8.19.5.3.2" class="indexterm"></a><pre class="synopsis">

  18. <code class="function">xmlcomment</code>(<em class="replaceable"><code>text</code></em>)

  19. </pre><p>

  20.      The function <code class="function">xmlcomment</code> creates an XML value

  21.      containing an XML comment with the specified text as content.

  22.      The text cannot contain <span class="quote">“<span class="quote"><code class="literal">--</code></span>”</span> or end with a

  23.      <span class="quote">“<span class="quote"><code class="literal">-</code></span>”</span> so that the resulting construct is a valid

  24.      XML comment.  If the argument is null, the result is null.

  25.     </p><p>

  26.      Example:

  27. </p><pre class="screen">

  28. SELECT xmlcomment('hello');

  29. 

  30.   xmlcomment

  31. --------------

  32.  &lt;!--hello--&gt;

  33. </pre><p>

  34.     </p></div><div class="sect3" id="id-1.5.8.19.5.4"><div class="titlepage"><div><div><h4 class="title">9.14.1.2. <code class="literal">xmlconcat</code></h4></div></div></div><a id="id-1.5.8.19.5.4.2" class="indexterm"></a><pre class="synopsis">

  35. <code class="function">xmlconcat</code>(<em class="replaceable"><code>xml</code></em>[<span class="optional">, ...</span>])

  36. </pre><p>

  37.      The function <code class="function">xmlconcat</code> concatenates a list

  38.      of individual XML values to create a single value containing an

  39.      XML content fragment.  Null values are omitted; the result is

  40.      only null if there are no nonnull arguments.

  41.     </p><p>

  42.      Example:

  43. </p><pre class="screen">

  44. SELECT xmlconcat('&lt;abc/&gt;', '&lt;bar&gt;foo&lt;/bar&gt;');

  45. 

  46.       xmlconcat

  47. ----------------------

  48.  &lt;abc/&gt;&lt;bar&gt;foo&lt;/bar&gt;

  49. </pre><p>

  50.     </p><p>

  51.      XML declarations, if present, are combined as follows.  If all

  52.      argument values have the same XML version declaration, that

  53.      version is used in the result, else no version is used.  If all

  54.      argument values have the standalone declaration value

  55.      <span class="quote">“<span class="quote">yes</span>”</span>, then that value is used in the result.  If

  56.      all argument values have a standalone declaration value and at

  57.      least one is <span class="quote">“<span class="quote">no</span>”</span>, then that is used in the result.

  58.      Else the result will have no standalone declaration.  If the

  59.      result is determined to require a standalone declaration but no

  60.      version declaration, a version declaration with version 1.0 will

  61.      be used because XML requires an XML declaration to contain a

  62.      version declaration.  Encoding declarations are ignored and

  63.      removed in all cases.

  64.     </p><p>

  65.      Example:

  66. </p><pre class="screen">

  67. SELECT xmlconcat('&lt;?xml version="1.1"?&gt;&lt;foo/&gt;', '&lt;?xml version="1.1" standalone="no"?&gt;&lt;bar/&gt;');

  68. 

  69.              xmlconcat

  70. -----------------------------------

  71.  &lt;?xml version="1.1"?&gt;&lt;foo/&gt;&lt;bar/&gt;

  72. </pre><p>

  73.     </p></div><div class="sect3" id="id-1.5.8.19.5.5"><div class="titlepage"><div><div><h4 class="title">9.14.1.3. <code class="literal">xmlelement</code></h4></div></div></div><a id="id-1.5.8.19.5.5.2" class="indexterm"></a><pre class="synopsis">

  74. <code class="function">xmlelement</code>(name <em class="replaceable"><code>name</code></em> [<span class="optional">, xmlattributes(<em class="replaceable"><code>value</code></em> [<span class="optional">AS <em class="replaceable"><code>attname</code></em></span>] [<span class="optional">, ... </span>])</span>] [<span class="optional"><em class="replaceable"><code>, content, ...</code></em></span>])

  75. </pre><p>

  76.      The <code class="function">xmlelement</code> expression produces an XML

  77.      element with the given name, attributes, and content.

  78.     </p><p>

  79.      Examples:

  80. </p><pre class="screen">

  81. SELECT xmlelement(name foo);

  82. 

  83.  xmlelement

  84. ------------

  85.  &lt;foo/&gt;

  86. 

  87. SELECT xmlelement(name foo, xmlattributes('xyz' as bar));

  88. 

  89.     xmlelement

  90. ------------------

  91.  &lt;foo bar="xyz"/&gt;

  92. 

  93. SELECT xmlelement(name foo, xmlattributes(current_date as bar), 'cont', 'ent');

  94. 

  95.              xmlelement

  96. -------------------------------------

  97.  &lt;foo bar="2007-01-26"&gt;content&lt;/foo&gt;

  98. </pre><p>

  99.     </p><p>

  100.      Element and attribute names that are not valid XML names are

  101.      escaped by replacing the offending characters by the sequence

  102.      <code class="literal">_x<em class="replaceable"><code>HHHH</code></em>_</code>, where

  103.      <em class="replaceable"><code>HHHH</code></em> is the character's Unicode

  104.      codepoint in hexadecimal notation.  For example:

  105. </p><pre class="screen">

  106. SELECT xmlelement(name "foo$bar", xmlattributes('xyz' as "a&amp;b"));

  107. 

  108.             xmlelement

  109. ----------------------------------

  110.  &lt;foo_x0024_bar a_x0026_b="xyz"/&gt;

  111. </pre><p>

  112.     </p><p>

  113.      An explicit attribute name need not be specified if the attribute

  114.      value is a column reference, in which case the column's name will

  115.      be used as the attribute name by default.  In other cases, the

  116.      attribute must be given an explicit name.  So this example is

  117.      valid:

  118. </p><pre class="screen">

  119. CREATE TABLE test (a xml, b xml);

  120. SELECT xmlelement(name test, xmlattributes(a, b)) FROM test;

  121. </pre><p>

  122.      But these are not:

  123. </p><pre class="screen">

  124. SELECT xmlelement(name test, xmlattributes('constant'), a, b) FROM test;

  125. SELECT xmlelement(name test, xmlattributes(func(a, b))) FROM test;

  126. </pre><p>

  127.     </p><p>

  128.      Element content, if specified, will be formatted according to

  129.      its data type.  If the content is itself of type <code class="type">xml</code>,

  130.      complex XML documents can be constructed.  For example:

  131. </p><pre class="screen">

  132. SELECT xmlelement(name foo, xmlattributes('xyz' as bar),

  133.                             xmlelement(name abc),

  134.                             xmlcomment('test'),

  135.                             xmlelement(name xyz));

  136. 

  137.                   xmlelement

  138. ----------------------------------------------

  139.  &lt;foo bar="xyz"&gt;&lt;abc/&gt;&lt;!--test--&gt;&lt;xyz/&gt;&lt;/foo&gt;

  140. </pre><p>

  141. 

  142.      Content of other types will be formatted into valid XML character

  143.      data.  This means in particular that the characters &lt;, &gt;,

  144.      and &amp; will be converted to entities.  Binary data (data type

  145.      <code class="type">bytea</code>) will be represented in base64 or hex

  146.      encoding, depending on the setting of the configuration parameter

  147.      <a class="xref" href="runtime-config-client.html#GUC-XMLBINARY">xmlbinary</a>.  The particular behavior for

  148.      individual data types is expected to evolve in order to align the

  149.      PostgreSQL mappings with those specified in SQL:2006 and later,

  150.      as discussed in <a class="xref" href="xml-limits-conformance.html#FUNCTIONS-XML-LIMITS-CASTS" title="D.3.1.3. Mappings between SQL and XML Data Types and Values">Section D.3.1.3</a>.

  151.     </p></div><div class="sect3" id="id-1.5.8.19.5.6"><div class="titlepage"><div><div><h4 class="title">9.14.1.4. <code class="literal">xmlforest</code></h4></div></div></div><a id="id-1.5.8.19.5.6.2" class="indexterm"></a><pre class="synopsis">

  152. <code class="function">xmlforest</code>(<em class="replaceable"><code>content</code></em> [<span class="optional">AS <em class="replaceable"><code>name</code></em></span>] [<span class="optional">, ...</span>])

  153. </pre><p>

  154.      The <code class="function">xmlforest</code> expression produces an XML

  155.      forest (sequence) of elements using the given names and content.

  156.     </p><p>

  157.      Examples:

  158. </p><pre class="screen">

  159. SELECT xmlforest('abc' AS foo, 123 AS bar);

  160. 

  161.           xmlforest

  162. ------------------------------

  163.  &lt;foo&gt;abc&lt;/foo&gt;&lt;bar&gt;123&lt;/bar&gt;

  164. 

  165. 

  166. SELECT xmlforest(table_name, column_name)

  167. FROM information_schema.columns

  168. WHERE table_schema = 'pg_catalog';

  169. 

  170.                                          xmlforest

  171. -------------------------------------------------------------------------------------------

  172.  &lt;table_name&gt;pg_authid&lt;/table_name&gt;&lt;column_name&gt;rolname&lt;/column_name&gt;

  173.  &lt;table_name&gt;pg_authid&lt;/table_name&gt;&lt;column_name&gt;rolsuper&lt;/column_name&gt;

  174.  ...

  175. </pre><p>

  176. 

  177.      As seen in the second example, the element name can be omitted if

  178.      the content value is a column reference, in which case the column

  179.      name is used by default.  Otherwise, a name must be specified.

  180.     </p><p>

  181.      Element names that are not valid XML names are escaped as shown

  182.      for <code class="function">xmlelement</code> above.  Similarly, content

  183.      data is escaped to make valid XML content, unless it is already

  184.      of type <code class="type">xml</code>.

  185.     </p><p>

  186.      Note that XML forests are not valid XML documents if they consist

  187.      of more than one element, so it might be useful to wrap

  188.      <code class="function">xmlforest</code> expressions in

  189.      <code class="function">xmlelement</code>.

  190.     </p></div><div class="sect3" id="id-1.5.8.19.5.7"><div class="titlepage"><div><div><h4 class="title">9.14.1.5. <code class="literal">xmlpi</code></h4></div></div></div><a id="id-1.5.8.19.5.7.2" class="indexterm"></a><pre class="synopsis">

  191. <code class="function">xmlpi</code>(name <em class="replaceable"><code>target</code></em> [<span class="optional">, <em class="replaceable"><code>content</code></em></span>])

  192. </pre><p>

  193.      The <code class="function">xmlpi</code> expression creates an XML

  194.      processing instruction.  The content, if present, must not

  195.      contain the character sequence <code class="literal">?&gt;</code>.

  196.     </p><p>

  197.      Example:

  198. </p><pre class="screen">

  199. SELECT xmlpi(name php, 'echo "hello world";');

  200. 

  201.             xmlpi

  202. -----------------------------

  203.  &lt;?php echo "hello world";?&gt;

  204. </pre><p>

  205.     </p></div><div class="sect3" id="id-1.5.8.19.5.8"><div class="titlepage"><div><div><h4 class="title">9.14.1.6. <code class="literal">xmlroot</code></h4></div></div></div><a id="id-1.5.8.19.5.8.2" class="indexterm"></a><pre class="synopsis">

  206. <code class="function">xmlroot</code>(<em class="replaceable"><code>xml</code></em>, version <em class="replaceable"><code>text</code></em> | no value [<span class="optional">, standalone yes|no|no value</span>])

  207. </pre><p>

  208.      The <code class="function">xmlroot</code> expression alters the properties

  209.      of the root node of an XML value.  If a version is specified,

  210.      it replaces the value in the root node's version declaration; if a

  211.      standalone setting is specified, it replaces the value in the

  212.      root node's standalone declaration.

  213.     </p><p>

  214. </p><pre class="screen">

  215. SELECT xmlroot(xmlparse(document '&lt;?xml version="1.1"?&gt;&lt;content&gt;abc&lt;/content&gt;'),

  216.                version '1.0', standalone yes);

  217. 

  218.                 xmlroot

  219. ----------------------------------------

  220.  &lt;?xml version="1.0" standalone="yes"?&gt;

  221.  &lt;content&gt;abc&lt;/content&gt;

  222. </pre><p>

  223.     </p></div><div class="sect3" id="FUNCTIONS-XML-XMLAGG"><div class="titlepage"><div><div><h4 class="title">9.14.1.7. <code class="literal">xmlagg</code></h4></div></div></div><a id="id-1.5.8.19.5.9.2" class="indexterm"></a><pre class="synopsis">

  224. <code class="function">xmlagg</code>(<em class="replaceable"><code>xml</code></em>)

  225. </pre><p>

  226.      The function <code class="function">xmlagg</code> is, unlike the other

  227.      functions described here, an aggregate function.  It concatenates the

  228.      input values to the aggregate function call,

  229.      much like <code class="function">xmlconcat</code> does, except that concatenation

  230.      occurs across rows rather than across expressions in a single row.

  231.      See <a class="xref" href="functions-aggregate.html" title="9.20. Aggregate Functions">Section 9.20</a> for additional information

  232.      about aggregate functions.

  233.     </p><p>

  234.      Example:

  235. </p><pre class="screen">

  236. CREATE TABLE test (y int, x xml);

  237. INSERT INTO test VALUES (1, '&lt;foo&gt;abc&lt;/foo&gt;');

  238. INSERT INTO test VALUES (2, '&lt;bar/&gt;');

  239. SELECT xmlagg(x) FROM test;

  240.         xmlagg

  241. ----------------------

  242.  &lt;foo&gt;abc&lt;/foo&gt;&lt;bar/&gt;

  243. </pre><p>

  244.     </p><p>

  245.      To determine the order of the concatenation, an <code class="literal">ORDER BY</code>

  246.      clause may be added to the aggregate call as described in

  247.      <a class="xref" href="sql-expressions.html#SYNTAX-AGGREGATES" title="4.2.7. Aggregate Expressions">Section 4.2.7</a>. For example:

  248. 

  249. </p><pre class="screen">

  250. SELECT xmlagg(x ORDER BY y DESC) FROM test;

  251.         xmlagg

  252. ----------------------

  253.  &lt;bar/&gt;&lt;foo&gt;abc&lt;/foo&gt;

  254. </pre><p>

  255.     </p><p>

  256.      The following non-standard approach used to be recommended

  257.      in previous versions, and may still be useful in specific

  258.      cases:

  259. 

  260. </p><pre class="screen">

  261. SELECT xmlagg(x) FROM (SELECT * FROM test ORDER BY y DESC) AS tab;

  262.         xmlagg

  263. ----------------------

  264.  &lt;bar/&gt;&lt;foo&gt;abc&lt;/foo&gt;

  265. </pre><p>

  266.     </p></div></div><div class="sect2" id="FUNCTIONS-XML-PREDICATES"><div class="titlepage"><div><div><h3 class="title">9.14.2. XML Predicates</h3></div></div></div><p>

  267.      The expressions described in this section check properties

  268.      of <code class="type">xml</code> values.

  269.     </p><div class="sect3" id="id-1.5.8.19.6.3"><div class="titlepage"><div><div><h4 class="title">9.14.2.1. <code class="literal">IS DOCUMENT</code></h4></div></div></div><a id="id-1.5.8.19.6.3.2" class="indexterm"></a><pre class="synopsis">

  270. <em class="replaceable"><code>xml</code></em> IS DOCUMENT

  271. </pre><p>

  272.      The expression <code class="literal">IS DOCUMENT</code> returns true if the

  273.      argument XML value is a proper XML document, false if it is not

  274.      (that is, it is a content fragment), or null if the argument is

  275.      null.  See <a class="xref" href="datatype-xml.html" title="8.13. XML Type">Section 8.13</a> about the difference

  276.      between documents and content fragments.

  277.     </p></div><div class="sect3" id="id-1.5.8.19.6.4"><div class="titlepage"><div><div><h4 class="title">9.14.2.2. <code class="literal">IS NOT DOCUMENT</code></h4></div></div></div><a id="id-1.5.8.19.6.4.2" class="indexterm"></a><pre class="synopsis">

  278. <em class="replaceable"><code>xml</code></em> IS NOT DOCUMENT

  279. </pre><p>

  280.      The expression <code class="literal">IS NOT DOCUMENT</code> returns false if the

  281.      argument XML value is a proper XML document, true if it is not (that is,

  282.      it is a content fragment), or null if the argument is null.

  283.     </p></div><div class="sect3" id="XML-EXISTS"><div class="titlepage"><div><div><h4 class="title">9.14.2.3. <code class="literal">XMLEXISTS</code></h4></div></div></div><a id="id-1.5.8.19.6.5.2" class="indexterm"></a><pre class="synopsis">

  284. <code class="function">XMLEXISTS</code>(<em class="replaceable"><code>text</code></em> PASSING [<span class="optional">BY { REF | VALUE }</span>] <em class="replaceable"><code>xml</code></em> [<span class="optional">BY { REF | VALUE }</span>])

  285. </pre><p>

  286.      The function <code class="function">xmlexists</code> evaluates an XPath 1.0

  287.      expression (the first argument), with the passed XML value as its context

  288.      item.  The function returns false if the result of that evaluation

  289.      yields an empty node-set, true if it yields any other value.  The

  290.      function returns null if any argument is null.  A nonnull value

  291.      passed as the context item must be an XML document, not a content

  292.      fragment or any non-XML value.

  293.     </p><p>

  294.      Example:

  295.      </p><pre class="screen">

  296. SELECT xmlexists('//town[text() = ''Toronto'']' PASSING BY VALUE '&lt;towns&gt;&lt;town&gt;Toronto&lt;/town&gt;&lt;town&gt;Ottawa&lt;/town&gt;&lt;/towns&gt;');

  297. 

  298.  xmlexists

  299. ------------

  300.  t

  301. (1 row)

  302. </pre><p>

  303.     </p><p>

  304.      The <code class="literal">BY REF</code> and <code class="literal">BY VALUE</code> clauses

  305.      are accepted in <span class="productname">PostgreSQL</span>, but are ignored,

  306.      as discussed in <a class="xref" href="xml-limits-conformance.html#FUNCTIONS-XML-LIMITS-POSTGRESQL" title="D.3.2.  Incidental Limits of the Implementation">Section D.3.2</a>.

  307.      In the SQL standard, the <code class="function">xmlexists</code> function

  308.      evaluates an expression in the XML Query language,

  309.      but <span class="productname">PostgreSQL</span> allows only an XPath 1.0

  310.      expression, as discussed in

  311.      <a class="xref" href="xml-limits-conformance.html#FUNCTIONS-XML-LIMITS-XPATH1" title="D.3.1. Queries Are Restricted to XPath 1.0">Section D.3.1</a>.

  312.     </p></div><div class="sect3" id="XML-IS-WELL-FORMED"><div class="titlepage"><div><div><h4 class="title">9.14.2.4. <code class="literal">xml_is_well_formed</code></h4></div></div></div><a id="id-1.5.8.19.6.6.2" class="indexterm"></a><a id="id-1.5.8.19.6.6.3" class="indexterm"></a><a id="id-1.5.8.19.6.6.4" class="indexterm"></a><pre class="synopsis">

  313. <code class="function">xml_is_well_formed</code>(<em class="replaceable"><code>text</code></em>)

  314. <code class="function">xml_is_well_formed_document</code>(<em class="replaceable"><code>text</code></em>)

  315. <code class="function">xml_is_well_formed_content</code>(<em class="replaceable"><code>text</code></em>)

  316. </pre><p>

  317.      These functions check whether a <code class="type">text</code> string is well-formed XML,

  318.      returning a Boolean result.

  319.      <code class="function">xml_is_well_formed_document</code> checks for a well-formed

  320.      document, while <code class="function">xml_is_well_formed_content</code> checks

  321.      for well-formed content.  <code class="function">xml_is_well_formed</code> does

  322.      the former if the <a class="xref" href="runtime-config-client.html#GUC-XMLOPTION">xmloption</a> configuration

  323.      parameter is set to <code class="literal">DOCUMENT</code>, or the latter if it is set to

  324.      <code class="literal">CONTENT</code>.  This means that

  325.      <code class="function">xml_is_well_formed</code> is useful for seeing whether

  326.      a simple cast to type <code class="type">xml</code> will succeed, whereas the other two

  327.      functions are useful for seeing whether the corresponding variants of

  328.      <code class="function">XMLPARSE</code> will succeed.

  329.     </p><p>

  330.      Examples:

  331. 

  332. </p><pre class="screen">

  333. SET xmloption TO DOCUMENT;

  334. SELECT xml_is_well_formed('&lt;&gt;');

  335.  xml_is_well_formed 

  336. --------------------

  337.  f

  338. (1 row)

  339. 

  340. SELECT xml_is_well_formed('&lt;abc/&gt;');

  341.  xml_is_well_formed 

  342. --------------------

  343.  t

  344. (1 row)

  345. 

  346. SET xmloption TO CONTENT;

  347. SELECT xml_is_well_formed('abc');

  348.  xml_is_well_formed 

  349. --------------------

  350.  t

  351. (1 row)

  352. 

  353. SELECT xml_is_well_formed_document('&lt;pg:foo xmlns:pg="http://postgresql.org/stuff"&gt;bar&lt;/pg:foo&gt;');

  354.  xml_is_well_formed_document 

  355. -----------------------------

  356.  t

  357. (1 row)

  358. 

  359. SELECT xml_is_well_formed_document('&lt;pg:foo xmlns:pg="http://postgresql.org/stuff"&gt;bar&lt;/my:foo&gt;');

  360.  xml_is_well_formed_document 

  361. -----------------------------

  362.  f

  363. (1 row)

  364. </pre><p>

  365. 

  366.      The last example shows that the checks include whether

  367.      namespaces are correctly matched.

  368.     </p></div></div><div class="sect2" id="FUNCTIONS-XML-PROCESSING"><div class="titlepage"><div><div><h3 class="title">9.14.3. Processing XML</h3></div></div></div><p>

  369.     To process values of data type <code class="type">xml</code>, PostgreSQL offers

  370.     the functions <code class="function">xpath</code> and

  371.     <code class="function">xpath_exists</code>, which evaluate XPath 1.0

  372.     expressions, and the <code class="function">XMLTABLE</code>

  373.     table function.

  374.    </p><div class="sect3" id="FUNCTIONS-XML-PROCESSING-XPATH"><div class="titlepage"><div><div><h4 class="title">9.14.3.1. <code class="literal">xpath</code></h4></div></div></div><a id="id-1.5.8.19.7.3.2" class="indexterm"></a><pre class="synopsis">

  375. <code class="function">xpath</code>(<em class="replaceable"><code>xpath</code></em>, <em class="replaceable"><code>xml</code></em> [<span class="optional">, <em class="replaceable"><code>nsarray</code></em></span>])

  376. </pre><p>

  377.      The function <code class="function">xpath</code> evaluates the XPath 1.0

  378.      expression <em class="replaceable"><code>xpath</code></em> (a <code class="type">text</code> value)

  379.      against the XML value

  380.      <em class="replaceable"><code>xml</code></em>.  It returns an array of XML values

  381.      corresponding to the node-set produced by the XPath expression.

  382.      If the XPath expression returns a scalar value rather than a node-set,

  383.      a single-element array is returned.

  384.     </p><p>

  385.      The second argument must be a well formed XML document. In particular,

  386.      it must have a single root node element.

  387.     </p><p>

  388.      The optional third argument of the function is an array of namespace

  389.      mappings.  This array should be a two-dimensional <code class="type">text</code> array with

  390.      the length of the second axis being equal to 2 (i.e., it should be an

  391.      array of arrays, each of which consists of exactly 2 elements).

  392.      The first element of each array entry is the namespace name (alias), the

  393.      second the namespace URI. It is not required that aliases provided in

  394.      this array be the same as those being used in the XML document itself (in

  395.      other words, both in the XML document and in the <code class="function">xpath</code>

  396.      function context, aliases are <span class="emphasis"><em>local</em></span>).

  397.     </p><p>

  398.      Example:

  399. </p><pre class="screen">

  400. SELECT xpath('/my:a/text()', '&lt;my:a xmlns:my="http://example.com"&gt;test&lt;/my:a&gt;',

  401.              ARRAY[ARRAY['my', 'http://example.com']]);

  402. 

  403.  xpath  

  404. --------

  405.  {test}

  406. (1 row)

  407. </pre><p>

  408.     </p><p>

  409.      To deal with default (anonymous) namespaces, do something like this:

  410. </p><pre class="screen">

  411. SELECT xpath('//mydefns:b/text()', '&lt;a xmlns="http://example.com"&gt;&lt;b&gt;test&lt;/b&gt;&lt;/a&gt;',

  412.              ARRAY[ARRAY['mydefns', 'http://example.com']]);

  413. 

  414.  xpath

  415. --------

  416.  {test}

  417. (1 row)

  418. </pre><p>

  419.     </p></div><div class="sect3" id="FUNCTIONS-XML-PROCESSING-XPATH-EXISTS"><div class="titlepage"><div><div><h4 class="title">9.14.3.2. <code class="literal">xpath_exists</code></h4></div></div></div><a id="id-1.5.8.19.7.4.2" class="indexterm"></a><pre class="synopsis">

  420. <code class="function">xpath_exists</code>(<em class="replaceable"><code>xpath</code></em>, <em class="replaceable"><code>xml</code></em> [<span class="optional">, <em class="replaceable"><code>nsarray</code></em></span>])

  421. </pre><p>

  422.      The function <code class="function">xpath_exists</code> is a specialized form

  423.      of the <code class="function">xpath</code> function.  Instead of returning the

  424.      individual XML values that satisfy the XPath 1.0 expression, this function

  425.      returns a Boolean indicating whether the query was satisfied or not

  426.      (specifically, whether it produced any value other than an empty node-set).

  427.      This function is equivalent to the <code class="literal">XMLEXISTS</code> predicate,

  428.      except that it also offers support for a namespace mapping argument.

  429.     </p><p>

  430.      Example:

  431. </p><pre class="screen">

  432. SELECT xpath_exists('/my:a/text()', '&lt;my:a xmlns:my="http://example.com"&gt;test&lt;/my:a&gt;',

  433.                      ARRAY[ARRAY['my', 'http://example.com']]);

  434. 

  435.  xpath_exists  

  436. --------------

  437.  t

  438. (1 row)

  439. </pre><p>

  440.     </p></div><div class="sect3" id="FUNCTIONS-XML-PROCESSING-XMLTABLE"><div class="titlepage"><div><div><h4 class="title">9.14.3.3. <code class="literal">xmltable</code></h4></div></div></div><a id="id-1.5.8.19.7.5.2" class="indexterm"></a><a id="id-1.5.8.19.7.5.3" class="indexterm"></a><pre class="synopsis">

  441. <code class="function">xmltable</code>( [<span class="optional">XMLNAMESPACES(<em class="replaceable"><code>namespace uri</code></em> AS <em class="replaceable"><code>namespace name</code></em>[<span class="optional">, ...</span>]), </span>]

  442.           <em class="replaceable"><code>row_expression</code></em> PASSING [<span class="optional">BY { REF | VALUE }</span>] <em class="replaceable"><code>document_expression</code></em> [<span class="optional">BY { REF | VALUE }</span>]

  443.           COLUMNS <em class="replaceable"><code>name</code></em> { <em class="replaceable"><code>type</code></em> [<span class="optional">PATH <em class="replaceable"><code>column_expression</code></em></span>] [<span class="optional">DEFAULT <em class="replaceable"><code>default_expression</code></em></span>] [<span class="optional">NOT NULL | NULL</span>]

  444.                         | FOR ORDINALITY }

  445.                    [<span class="optional">, ...</span>]

  446. )

  447. </pre><p>

  448.      The <code class="function">xmltable</code> function produces a table based

  449.      on the given XML value, an XPath filter to extract rows, and a

  450.      set of column definitions.

  451.     </p><p>

  452.      The optional <code class="literal">XMLNAMESPACES</code> clause is a comma-separated

  453.      list of namespaces.  It specifies the XML namespaces used in

  454.      the document and their aliases. A default namespace specification

  455.      is not currently supported.

  456.     </p><p>

  457.      The required <em class="replaceable"><code>row_expression</code></em> argument is

  458.      an XPath 1.0 expression that is evaluated, passing the

  459.      <em class="replaceable"><code>document_expression</code></em> as its context item, to

  460.      obtain a set of XML nodes. These nodes are what

  461.      <code class="function">xmltable</code> transforms into output rows. No rows

  462.      will be produced if the <em class="replaceable"><code>document_expression</code></em>

  463.      is null, nor if the <em class="replaceable"><code>row_expression</code></em> produces

  464.      an empty node-set or any value other than a node-set.

  465.     </p><p>

  466.      <em class="replaceable"><code>document_expression</code></em> provides the context

  467.      item for the <em class="replaceable"><code>row_expression</code></em>. It must be a

  468.      well-formed XML document; fragments/forests are not accepted.

  469.      The <code class="literal">BY REF</code> and <code class="literal">BY VALUE</code> clauses

  470.      are accepted but ignored, as discussed in

  471.      <a class="xref" href="xml-limits-conformance.html#FUNCTIONS-XML-LIMITS-POSTGRESQL" title="D.3.2.  Incidental Limits of the Implementation">Section D.3.2</a>.

  472.      In the SQL standard, the <code class="function">xmltable</code> function

  473.      evaluates expressions in the XML Query language,

  474.      but <span class="productname">PostgreSQL</span> allows only XPath 1.0

  475.      expressions, as discussed in

  476.      <a class="xref" href="xml-limits-conformance.html#FUNCTIONS-XML-LIMITS-XPATH1" title="D.3.1. Queries Are Restricted to XPath 1.0">Section D.3.1</a>.

  477.     </p><p>

  478.      The mandatory <code class="literal">COLUMNS</code> clause specifies the list

  479.      of columns in the output table.

  480.      Each entry describes a single column.

  481.      See the syntax summary above for the format.

  482.      The column name and type are required; the path, default and

  483.      nullability clauses are optional.

  484.     </p><p>

  485.      A column marked <code class="literal">FOR ORDINALITY</code> will be populated

  486.      with row numbers, starting with 1, in the order of nodes retrieved from

  487.      the <em class="replaceable"><code>row_expression</code></em>'s result node-set.

  488.      At most one column may be marked <code class="literal">FOR ORDINALITY</code>.

  489.     </p><div class="note"><h3 class="title">Note</h3><p>

  490.       XPath 1.0 does not specify an order for nodes in a node-set, so code

  491.       that relies on a particular order of the results will be

  492.       implementation-dependent.  Details can be found in

  493.       <a class="xref" href="xml-limits-conformance.html#XML-XPATH-1-SPECIFICS" title="D.3.1.2. Restriction of XPath to 1.0">Section D.3.1.2</a>.

  494.      </p></div><p>

  495.      The <em class="replaceable"><code>column_expression</code></em> for a column is an

  496.      XPath 1.0 expression that is evaluated for each row, with the current

  497.      node from the <em class="replaceable"><code>row_expression</code></em> result as its

  498.      context item, to find the value of the column.  If

  499.      no <em class="replaceable"><code>column_expression</code></em> is given, then the

  500.      column name is used as an implicit path.

  501.     </p><p>

  502.      If a column's XPath expression returns a non-XML value (limited to

  503.      string, boolean, or double in XPath 1.0) and the column has a

  504.      PostgreSQL type other than <code class="type">xml</code>, the column will be set

  505.      as if by assigning the value's string representation to the PostgreSQL

  506.      type.  (If the value is a boolean, its string representation is taken

  507.      to be <code class="literal">1</code> or <code class="literal">0</code> if the output

  508.      column's type category is numeric, otherwise <code class="literal">true</code> or

  509.      <code class="literal">false</code>.)

  510.     </p><p>

  511.      If a column's XPath expression returns a non-empty set of XML nodes

  512.      and the column's PostgreSQL type is <code class="type">xml</code>, the column will

  513.      be assigned the expression result exactly, if it is of document or

  514.      content form.

  515.      <a href="#ftn.id-1.5.8.19.7.5.14.2" class="footnote"><sup class="footnote" id="id-1.5.8.19.7.5.14.2">[8]</sup></a>

  516.     </p><p>

  517.      A non-XML result assigned to an <code class="type">xml</code> output column produces

  518.      content, a single text node with the string value of the result.

  519.      An XML result assigned to a column of any other type may not have more than

  520.      one node, or an error is raised. If there is exactly one node, the column

  521.      will be set as if by assigning the node's string

  522.      value (as defined for the XPath 1.0 <code class="function">string</code> function)

  523.      to the PostgreSQL type.

  524.     </p><p>

  525.      The string value of an XML element is the concatenation, in document order,

  526.      of all text nodes contained in that element and its descendants. The string

  527.      value of an element with no descendant text nodes is an

  528.      empty string (not <code class="literal">NULL</code>).

  529.      Any <code class="literal">xsi:nil</code> attributes are ignored.

  530.      Note that the whitespace-only <code class="literal">text()</code> node between two non-text

  531.      elements is preserved, and that leading whitespace on a <code class="literal">text()</code>

  532.      node is not flattened.

  533.      The XPath 1.0 <code class="function">string</code> function may be consulted for the

  534.      rules defining the string value of other XML node types and non-XML values.

  535.     </p><p>

  536.      The conversion rules presented here are not exactly those of the SQL

  537.      standard, as discussed in <a class="xref" href="xml-limits-conformance.html#FUNCTIONS-XML-LIMITS-CASTS" title="D.3.1.3. Mappings between SQL and XML Data Types and Values">Section D.3.1.3</a>.

  538.     </p><p>

  539.      If the path expression returns an empty node-set

  540.      (typically, when it does not match)

  541.      for a given row, the column will be set to <code class="literal">NULL</code>, unless

  542.      a <em class="replaceable"><code>default_expression</code></em> is specified; then the

  543.      value resulting from evaluating that expression is used.

  544.     </p><p>

  545.      Columns may be marked <code class="literal">NOT NULL</code>. If the

  546.      <em class="replaceable"><code>column_expression</code></em> for a <code class="literal">NOT NULL</code> column

  547.      does not match anything and there is no <code class="literal">DEFAULT</code> or the

  548.      <em class="replaceable"><code>default_expression</code></em> also evaluates to null, an error

  549.      is reported.

  550.     </p><p>

  551.      A <em class="replaceable"><code>default_expression</code></em>, rather than being

  552.      evaluated immediately when <code class="function">xmltable</code> is called,

  553.      is evaluated each time a default is needed for the column.

  554.      If the expression qualifies as stable or immutable, the repeat

  555.      evaluation may be skipped.

  556.      This means that you can usefully use volatile functions like

  557.      <code class="function">nextval</code> in

  558.      <em class="replaceable"><code>default_expression</code></em>.

  559.     </p><p>

  560.      Examples:

  561.   </p><pre class="screen">

  562. CREATE TABLE xmldata AS SELECT

  563. xml $$

  564. &lt;ROWS&gt;

  565.   &lt;ROW id="1"&gt;

  566.     &lt;COUNTRY_ID&gt;AU&lt;/COUNTRY_ID&gt;

  567.     &lt;COUNTRY_NAME&gt;Australia&lt;/COUNTRY_NAME&gt;

  568.   &lt;/ROW&gt;

  569.   &lt;ROW id="5"&gt;

  570.     &lt;COUNTRY_ID&gt;JP&lt;/COUNTRY_ID&gt;

  571.     &lt;COUNTRY_NAME&gt;Japan&lt;/COUNTRY_NAME&gt;

  572.     &lt;PREMIER_NAME&gt;Shinzo Abe&lt;/PREMIER_NAME&gt;

  573.     &lt;SIZE unit="sq_mi"&gt;145935&lt;/SIZE&gt;

  574.   &lt;/ROW&gt;

  575.   &lt;ROW id="6"&gt;

  576.     &lt;COUNTRY_ID&gt;SG&lt;/COUNTRY_ID&gt;

  577.     &lt;COUNTRY_NAME&gt;Singapore&lt;/COUNTRY_NAME&gt;

  578.     &lt;SIZE unit="sq_km"&gt;697&lt;/SIZE&gt;

  579.   &lt;/ROW&gt;

  580. &lt;/ROWS&gt;

  581. $$ AS data;

  582. 

  583. SELECT xmltable.*

  584.   FROM xmldata,

  585.        XMLTABLE('//ROWS/ROW'

  586.                 PASSING data

  587.                 COLUMNS id int PATH '@id',

  588.                         ordinality FOR ORDINALITY,

  589.                         "COUNTRY_NAME" text,

  590.                         country_id text PATH 'COUNTRY_ID',

  591.                         size_sq_km float PATH 'SIZE[@unit = "sq_km"]',

  592.                         size_other text PATH

  593.                              'concat(SIZE[@unit!="sq_km"], " ", SIZE[@unit!="sq_km"]/@unit)',

  594.                         premier_name text PATH 'PREMIER_NAME' DEFAULT 'not specified') ;

  595. 

  596.  id | ordinality | COUNTRY_NAME | country_id | size_sq_km |  size_other  | premier_name  

  597. ----+------------+--------------+------------+------------+--------------+---------------

  598.   1 |          1 | Australia    | AU         |            |              | not specified

  599.   5 |          2 | Japan        | JP         |            | 145935 sq_mi | Shinzo Abe

  600.   6 |          3 | Singapore    | SG         |        697 |              | not specified

  601. </pre><p>

  602. 

  603.      The following example shows concatenation of multiple text() nodes,

  604.      usage of the column name as XPath filter, and the treatment of whitespace,

  605.      XML comments and processing instructions:

  606. 

  607.   </p><pre class="screen">

  608. CREATE TABLE xmlelements AS SELECT

  609. xml $$

  610.   &lt;root&gt;

  611.    &lt;element&gt;  Hello&lt;!-- xyxxz --&gt;2a2&lt;?aaaaa?&gt; &lt;!--x--&gt;  bbb&lt;x&gt;xxx&lt;/x&gt;CC  &lt;/element&gt;

  612.   &lt;/root&gt;

  613. $$ AS data;

  614. 

  615. SELECT xmltable.*

  616.   FROM xmlelements, XMLTABLE('/root' PASSING data COLUMNS element text);

  617.          element         

  618. -------------------------

  619.    Hello2a2   bbbxxxCC  

  620. </pre><p>

  621.     </p><p>

  622.      The following example illustrates how

  623.      the <code class="literal">XMLNAMESPACES</code> clause can be used to specify

  624.      a list of namespaces

  625.      used in the XML document as well as in the XPath expressions:

  626. 

  627.   </p><pre class="screen">

  628. WITH xmldata(data) AS (VALUES ('

  629. &lt;example xmlns="http://example.com/myns" xmlns:B="http://example.com/b"&gt;

  630.  &lt;item foo="1" B:bar="2"/&gt;

  631.  &lt;item foo="3" B:bar="4"/&gt;

  632.  &lt;item foo="4" B:bar="5"/&gt;

  633. &lt;/example&gt;'::xml)

  634. )

  635. SELECT xmltable.*

  636.   FROM XMLTABLE(XMLNAMESPACES('http://example.com/myns' AS x,

  637.                               'http://example.com/b' AS "B"),

  638.              '/x:example/x:item'

  639.                 PASSING (SELECT data FROM xmldata)

  640.                 COLUMNS foo int PATH '@foo',

  641.                   bar int PATH '@B:bar');

  642.  foo | bar

  643. -----+-----

  644.    1 |   2

  645.    3 |   4

  646.    4 |   5

  647. (3 rows)

  648. </pre><p>

  649.     </p></div></div><div class="sect2" id="FUNCTIONS-XML-MAPPING"><div class="titlepage"><div><div><h3 class="title">9.14.4. Mapping Tables to XML</h3></div></div></div><a id="id-1.5.8.19.8.2" class="indexterm"></a><p>

  650.     The following functions map the contents of relational tables to

  651.     XML values.  They can be thought of as XML export functionality:

  652. </p><pre class="synopsis">

  653. table_to_xml(tbl regclass, nulls boolean, tableforest boolean, targetns text)

  654. query_to_xml(query text, nulls boolean, tableforest boolean, targetns text)

  655. cursor_to_xml(cursor refcursor, count int, nulls boolean,

  656.               tableforest boolean, targetns text)

  657. </pre><p>

  658.     The return type of each function is <code class="type">xml</code>.

  659.    </p><p>

  660.     <code class="function">table_to_xml</code> maps the content of the named

  661.     table, passed as parameter <em class="parameter"><code>tbl</code></em>.  The

  662.     <code class="type">regclass</code> type accepts strings identifying tables using the

  663.     usual notation, including optional schema qualifications and

  664.     double quotes.  <code class="function">query_to_xml</code> executes the

  665.     query whose text is passed as parameter

  666.     <em class="parameter"><code>query</code></em> and maps the result set.

  667.     <code class="function">cursor_to_xml</code> fetches the indicated number of

  668.     rows from the cursor specified by the parameter

  669.     <em class="parameter"><code>cursor</code></em>.  This variant is recommended if

  670.     large tables have to be mapped, because the result value is built

  671.     up in memory by each function.

  672.    </p><p>

  673.     If <em class="parameter"><code>tableforest</code></em> is false, then the resulting

  674.     XML document looks like this:

  675. </p><pre class="screen">

  676. &lt;tablename&gt;

  677.   &lt;row&gt;

  678.     &lt;columnname1&gt;data&lt;/columnname1&gt;

  679.     &lt;columnname2&gt;data&lt;/columnname2&gt;

  680.   &lt;/row&gt;

  681. 

  682.   &lt;row&gt;

  683.     ...

  684.   &lt;/row&gt;

  685. 

  686.   ...

  687. &lt;/tablename&gt;

  688. </pre><p>

  689. 

  690.     If <em class="parameter"><code>tableforest</code></em> is true, the result is an

  691.     XML content fragment that looks like this:

  692. </p><pre class="screen">

  693. &lt;tablename&gt;

  694.   &lt;columnname1&gt;data&lt;/columnname1&gt;

  695.   &lt;columnname2&gt;data&lt;/columnname2&gt;

  696. &lt;/tablename&gt;

  697. 

  698. &lt;tablename&gt;

  699.   ...

  700. &lt;/tablename&gt;

  701. 

  702. ...

  703. </pre><p>

  704. 

  705.     If no table name is available, that is, when mapping a query or a

  706.     cursor, the string <code class="literal">table</code> is used in the first

  707.     format, <code class="literal">row</code> in the second format.

  708.    </p><p>

  709.     The choice between these formats is up to the user.  The first

  710.     format is a proper XML document, which will be important in many

  711.     applications.  The second format tends to be more useful in the

  712.     <code class="function">cursor_to_xml</code> function if the result values are to be

  713.     reassembled into one document later on.  The functions for

  714.     producing XML content discussed above, in particular

  715.     <code class="function">xmlelement</code>, can be used to alter the results

  716.     to taste.

  717.    </p><p>

  718.     The data values are mapped in the same way as described for the

  719.     function <code class="function">xmlelement</code> above.

  720.    </p><p>

  721.     The parameter <em class="parameter"><code>nulls</code></em> determines whether null

  722.     values should be included in the output.  If true, null values in

  723.     columns are represented as:

  724. </p><pre class="screen">

  725. &lt;columnname xsi:nil="true"/&gt;

  726. </pre><p>

  727.     where <code class="literal">xsi</code> is the XML namespace prefix for XML

  728.     Schema Instance.  An appropriate namespace declaration will be

  729.     added to the result value.  If false, columns containing null

  730.     values are simply omitted from the output.

  731.    </p><p>

  732.     The parameter <em class="parameter"><code>targetns</code></em> specifies the

  733.     desired XML namespace of the result.  If no particular namespace

  734.     is wanted, an empty string should be passed.

  735.    </p><p>

  736.     The following functions return XML Schema documents describing the

  737.     mappings performed by the corresponding functions above:

  738. </p><pre class="synopsis">

  739. table_to_xmlschema(tbl regclass, nulls boolean, tableforest boolean, targetns text)

  740. query_to_xmlschema(query text, nulls boolean, tableforest boolean, targetns text)

  741. cursor_to_xmlschema(cursor refcursor, nulls boolean, tableforest boolean, targetns text)

  742. </pre><p>

  743.     It is essential that the same parameters are passed in order to

  744.     obtain matching XML data mappings and XML Schema documents.

  745.    </p><p>

  746.     The following functions produce XML data mappings and the

  747.     corresponding XML Schema in one document (or forest), linked

  748.     together.  They can be useful where self-contained and

  749.     self-describing results are wanted:

  750. </p><pre class="synopsis">

  751. table_to_xml_and_xmlschema(tbl regclass, nulls boolean, tableforest boolean, targetns text)

  752. query_to_xml_and_xmlschema(query text, nulls boolean, tableforest boolean, targetns text)

  753. </pre><p>

  754.    </p><p>

  755.     In addition, the following functions are available to produce

  756.     analogous mappings of entire schemas or the entire current

  757.     database:

  758. </p><pre class="synopsis">

  759. schema_to_xml(schema name, nulls boolean, tableforest boolean, targetns text)

  760. schema_to_xmlschema(schema name, nulls boolean, tableforest boolean, targetns text)

  761. schema_to_xml_and_xmlschema(schema name, nulls boolean, tableforest boolean, targetns text)

  762. 

  763. database_to_xml(nulls boolean, tableforest boolean, targetns text)

  764. database_to_xmlschema(nulls boolean, tableforest boolean, targetns text)

  765. database_to_xml_and_xmlschema(nulls boolean, tableforest boolean, targetns text)

  766. </pre><p>

  767. 

  768.     Note that these potentially produce a lot of data, which needs to

  769.     be built up in memory.  When requesting content mappings of large

  770.     schemas or databases, it might be worthwhile to consider mapping the

  771.     tables separately instead, possibly even through a cursor.

  772.    </p><p>

  773.     The result of a schema content mapping looks like this:

  774. 

  775. </p><pre class="screen">

  776. &lt;schemaname&gt;

  777. 

  778. table1-mapping

  779. 

  780. table2-mapping

  781. 

  782. ...

  783. 

  784. &lt;/schemaname&gt;</pre><p>

  785. 

  786.     where the format of a table mapping depends on the

  787.     <em class="parameter"><code>tableforest</code></em> parameter as explained above.

  788.    </p><p>

  789.     The result of a database content mapping looks like this:

  790. 

  791. </p><pre class="screen">

  792. &lt;dbname&gt;

  793. 

  794. &lt;schema1name&gt;

  795.   ...

  796. &lt;/schema1name&gt;

  797. 

  798. &lt;schema2name&gt;

  799.   ...

  800. &lt;/schema2name&gt;

  801. 

  802. ...

  803. 

  804. &lt;/dbname&gt;</pre><p>

  805. 

  806.     where the schema mapping is as above.

  807.    </p><p>

  808.     As an example of using the output produced by these functions,

  809.     <a class="xref" href="functions-xml.html#XSLT-XML-HTML" title="Example 9.1. XSLT Stylesheet for Converting SQL/XML Output to HTML">Example 9.1</a> shows an XSLT stylesheet that

  810.     converts the output of

  811.     <code class="function">table_to_xml_and_xmlschema</code> to an HTML

  812.     document containing a tabular rendition of the table data.  In a

  813.     similar manner, the results from these functions can be

  814.     converted into other XML-based formats.

  815.    </p><div class="example" id="XSLT-XML-HTML"><p class="title"><strong>Example 9.1. XSLT Stylesheet for Converting SQL/XML Output to HTML</strong></p><div class="example-contents"><pre class="programlisting">

  816. &lt;?xml version="1.0"?&gt;

  817. &lt;xsl:stylesheet version="1.0"

  818.     xmlns:xsl="http://www.w3.org/1999/XSL/Transform"

  819.     xmlns:xsd="http://www.w3.org/2001/XMLSchema"

  820.     xmlns="http://www.w3.org/1999/xhtml"

  821. &gt;

  822. 

  823.   &lt;xsl:output method="xml"

  824.       doctype-system="http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"

  825.       doctype-public="-//W3C/DTD XHTML 1.0 Strict//EN"

  826.       indent="yes"/&gt;

  827. 

  828.   &lt;xsl:template match="/*"&gt;

  829.     &lt;xsl:variable name="schema" select="//xsd:schema"/&gt;

  830.     &lt;xsl:variable name="tabletypename"

  831.                   select="$schema/xsd:element[@name=name(current())]/@type"/&gt;

  832.     &lt;xsl:variable name="rowtypename"

  833.                   select="$schema/xsd:complexType[@name=$tabletypename]/xsd:sequence/xsd:element[@name='row']/@type"/&gt;

  834. 

  835.     &lt;html&gt;

  836.       &lt;head&gt;

  837.         &lt;title&gt;&lt;xsl:value-of select="name(current())"/&gt;&lt;/title&gt;

  838.       &lt;/head&gt;

  839.       &lt;body&gt;

  840.         &lt;table&gt;

  841.           &lt;tr&gt;

  842.             &lt;xsl:for-each select="$schema/xsd:complexType[@name=$rowtypename]/xsd:sequence/xsd:element/@name"&gt;

  843.               &lt;th&gt;&lt;xsl:value-of select="."/&gt;&lt;/th&gt;

  844.             &lt;/xsl:for-each&gt;

  845.           &lt;/tr&gt;

  846. 

  847.           &lt;xsl:for-each select="row"&gt;

  848.             &lt;tr&gt;

  849.               &lt;xsl:for-each select="*"&gt;

  850.                 &lt;td&gt;&lt;xsl:value-of select="."/&gt;&lt;/td&gt;

  851.               &lt;/xsl:for-each&gt;

  852.             &lt;/tr&gt;

  853.           &lt;/xsl:for-each&gt;

  854.         &lt;/table&gt;

  855.       &lt;/body&gt;

  856.     &lt;/html&gt;

  857.   &lt;/xsl:template&gt;

  858. 

  859. &lt;/xsl:stylesheet&gt;

  860. </pre></div></div><br class="example-break" /></div><div class="footnotes"><br /><hr style="width:100; text-align:left;margin-left: 0" /><div id="ftn.id-1.5.8.19.7.5.14.2" class="footnote"><p><a href="#id-1.5.8.19.7.5.14.2" class="para"><sup class="para">[8] </sup></a>

  861.        A result containing more than one element node at the top level, or

  862.        non-whitespace text outside of an element, is an example of content form.

  863.        An XPath result can be of neither form, for example if it returns an

  864.        attribute node selected from the element that contains it. Such a result

  865.        will be put into content form with each such disallowed node replaced by

  866.        its string value, as defined for the XPath 1.0

  867.        <code class="function">string</code> function.

  868.       </p></div></div></div><div class="navfooter"><hr /><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="functions-textsearch.html">Prev</a> </td><td width="20%" align="center"><a accesskey="u" href="functions.html">Up</a></td><td width="40%" align="right"> <a accesskey="n" href="functions-json.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">9.13. Text Search Functions and Operators </td><td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td><td width="40%" align="right" valign="top"> 9.15. JSON Functions and Operators</td></tr></table></div></body></html>
上海开阖软件有限公司 沪ICP备12045867号-1