Converts an XML tree, whose format corresponds to the XML representation of JSON defined in this specification, into a string conforming to the JSON grammar.
fn:xml-to-json
( $input
as node()?
xs:string?
fn:xml-to-json
( $input
as node()?
,$options
as map(*)
xs:string?
The effect of the one-argument form of this function is the same as calling the
two-argument form with an empty map as the value of the $options
argument.
The first argument $input
is a node; the subtree rooted at this node will typically be
the XML representation of a JSON document as defined in .
If $input
is the empty sequence, the function returns the empty sequence.
The $options
argument can be used to control the way in which the conversion
takes place. The option parameter conventions apply.
The entries that may appear in the $options
map are as follows:
The node supplied as $input
must be one of the following:
An element node whose name matches the name of a global element declaration in the schema given in ("the schema") and that is valid as defined below:
If the type annotation of the element matches the type of the relevant element declaration in the schema (indicating that the element has been validated against the schema), then the element is considered valid.
Otherwise, the processor may attempt to validate the element against the schema, in which case it is treated as valid if and only if the outcome of validation is valid.
Otherwise (if the processor does not attempt validation using the schema),
the processor must ensure that the content of the element,
after stripping all attributes (at any depth) in namespaces other than
http://www.w3.org/2005/xpath-functions
, is such that validation
against the schema would have an outcome of valid.
The process described here is not precisely equivalent to schema validation.
For example, schema validation will fail if there is an invalid xsi:type
or xsi:nil
attribute, whereas this process will ignore such attributes.
An element node E having a key
attribute and/or an escaped-key
attribute
provided that E would satisfy one of the above
conditions if the key
and/or escaped-key
attributes were removed.
A document node having exactly one element child and no text node children, where the element child satisfies one of the conditions above.
Furthermore, $input
must satisfy the following constraint
(which cannot be conveniently expressed in the schema). Every element M that is a descendant-or-self of
$input
and has local name map
and namespace URI http://www.w3.org/2005/xpath-functions
must satisfy the following rule: there must not be two distinct children of M (say C/1 and C/2)
such that the normalized key of C/1 is equal to the normalized key of C/2. The normalized key
of an element C is as follows:
If C has the attribute value escaped-key="true"
, then the value of the
key
attribute of C, with all JSON escape sequences replaced by the corresponding Unicode characters
according to the JSON escaping rules.
Otherwise (the escaped-key
attribute of C is absent or set to false),
the value of the key
attribute of C.
Nodes in the input tree are handled by applying the following rules, recursively. In these rules the term
"an element named N" means "an element node whose local name is N and whose namespace URI is
http://www.w3.org/2005/xpath-functions
".
A document node having a single element node child is processed by processing that child.
An element named null
results in the output null
.
An element $E
named boolean
results in the output true
or false
depending on the result of
xs:boolean(fn:string($E))
.
An element $E
named number
results in the output of the string
result of xs:string(xs:double(fn:string($E)))
An element named string
results in the output of the string value of the element, enclosed in
quotation marks, with any special characters in the string escaped as described below.
An element named array
results in the output of the children of the array
element,
each processed by applying these rules recursively: the items in the resulting list are enclosed between square brackets,
and separated by commas.
An element named map
results in the output of a sequence of map entries corresponding to
the children of the map
element, enclosed between curly braces and separated by commas.
Each entry comprises the value of the key
attribute of the child element, enclosed in quotation marks
and escaped as described below, followed by a colon, followed by the result of processing the child element
by applying these rules recursively.
Comments, processing instructions, and whitespace text node children of map
and array
are ignored.
Strings are escaped as follows:
If the attribute escaped="true"
is present for a string value, or escaped-key="true"
for a key value, then:
any valid JSON escape sequence present in the string is copied unchanged to the output;
any invalid JSON escape sequence results in a dynamic error ;
any unescaped occurrence of quotation mark, backspace, form-feed, newline, carriage return, tab, or solidus is replaced by
\"
, \b
, \f
, \n
, \r
, \t
, or \/
respectively;
any other codepoint in the range 1-31 or 127-159 is replaced by an escape in the form \uHHHH where HHHH is the upper-case hexadecimal representation of the codepoint value.
Otherwise (that is, in the absence of the attribute escaped="true"
for a string value,
or escaped-key="true"
for a key value):
any occurrence of backslash is replaced by \\
any occurrence of quotation mark, backspace, form-feed, newline, carriage return, or tab is
replaced by \"
, \b
, \f
, \n
, \r
, or \t
respectively;
any other codepoint in the range 1-31 or 127-159 is replaced by an escape in
the form \uHHHH
where HHHH
is the upper-case hexadecimal representation of the codepoint value.
The input <array xmlns="http://www.w3.org/2005/xpath-functions"><number>1</number><string>is</string><boolean>1</boolean></array>
produces the result [1,"is",true]
.
The input <map xmlns="http://www.w3.org/2005/xpath-functions"><number key="Sunday">1</number><number key="Monday">2</number></map>
produces the result {"Sunday":1,"Monday":2}
.
A dynamic error is raised if the value of
$options
includes an entry whose key is defined in this specification,
and whose value is not a permitted value for that key.
A dynamic error is raised if the value of
$input
is not a document or element node or is not valid according to the schema for the XML representation of
JSON, or if a map
element has two children whose normalized key values are the same.
A dynamic error is raised if the value of
$input
includes a string labeled with escaped="true"
, or
a key labeled with escaped-key="true"
, where the content of the string or key
contains an invalid JSON escape sequence: specifically, where it contains a backslash (\
) that is not followed by one
of the characters "
, \
, /
, b
, f
, n
,
r
, t
, or u
, or where it contains the characters \u
not followed by four hexadecimal digits (that is [0-9A-Fa-f]{4}
).
The rule requiring schema validity has a number of consequences, including the following:
http://www.w3.org/2005/xpath-functions
,
except where explicitly allowed by the schema. Attributes in other namespaces, however, are ignored.
Nodes that do not affect schema validity, such as comments, processing instructions, namespace nodes, and whitespace text node
children of map
and array
, are ignored.
Numeric values are restricted to those that are valid in JSON:
the schema disallows positive and negative infinity and NaN.
Duplicate key values are not permitted. Most cases of duplicate keys are prevented by the rules in the schema;
additional cases (where the keys are equal only after expanding JSON escape sequences) are prevented by the prose rules
of this function. For example, the key values \n
and \u000A
are treated as duplicates even though
the rules in the schema do not treat them as such.
The rule allowing the top-level element to have a key
attribute (which is ignored)
allows any element in the output of the fn:json-to-xml
function
to be processed: for example, it is possible to take a JSON document, convert it to XML, select
a subtree based on the value of a key
attribute, and then convert this subtree
back to JSON, perhaps after a transformation. The rule means that an element with the appropriate name will be
accepted if it has been validated against one of the
types mapWithinMapType
, arrayWithinMapType
, stringWithinMapType
,
numberWithinMapType
, booleanWithinMapType
, or nullWithinMapType
.