HermannSW

Please find description and script attached in this developerWorks forum posting:
https://www.ibm.com/developerworks/community/forums/html/topic?id=150cc609-34a6-4d39-aa52-9c83709bac29#fc2cae9a-1353-4b3f-9707-3551daf925ab

Here is just the script (check for "typeof XML" allows dynamical code execution):

 

 

Hermann _{<DataPower Blog/> <myBlog/> <myTweets/> <myChannel/> <GraphvizFiddle/>}

DataPower does provide many languages for you to do what is needed:

• Schema
• XSLT (XPath 1.0)
• XQuery/JSONiq (XPath 2.0)
• GatewayScript

 

Since ages extensions were available to mix languages like "dp:schema-validate()" ["dp:transform()"].

With 7.2.0.0 three new extensions became available for you to mix (if you want).

Here is what you can do (you can edit the graph if you want) as SVG, with links that point to Knowledge Center:

 

 

 

 

Hermann.

DataPower has a XSLT 1.0 processor since day 1 long ago (1999), and that provides XPath 1.0.
(There is a wealth of EXSLT as well as DataPower proprietary extension functions/elements)

With 6.0.0.0 firmware DataPower shipped XQuery 1.0 processor as well, and that provides XPath 2.0.
Any valid XPath 2.0 statement is a valid XQuery script by definition.
And there is a HUGE amount of functions and operators in XPath 2.0 (more than 250):
http://www.w3.org/TR/xpath-functions/

With 7.0.0.0 firmware released last Friday we got much new exciting stuff (I blogged on GatewayScript before).

Besides GatewayScipt (programming model, API reference) -- these are the other news from compiler side:

1. JSON Schema Validation (JSV) support for draft-04 of spec (6.0.0/6.0.1 support draft-03)
2. hybrid output method for XQuery/JSONiq is now available (in addition to "xml" and "json" from 6.0.0/6.0.1)
3. dp:xquery-transform(script, nodeset)

Today I want to talk on 3. which allows DataPower XSLT processor to "call out" to XQuery -- nice!

Last August Eric van der Vlist twittered on an XPath expression that allows to tell whether XPath processor is 1.0 or 2.0.
In this tweet I simplified (minimalized?) his expression to  (4=5)=/..

This expression just compares  false()  with an  empty nodeset  and that is true for XPath 1.0 and false for XPath 2.0.

This XPath expresion is stored here (in order to be accessible by my and your DataPower boxes):
http://stamm-wilbrandt.de/en/blog/isXPath1.xq

 

Now below stylesheet  isXPath1.xsl does evaluate above XPath expression in a singe concat statement:

$ coproc2 isXPath1.xsl dummy.xml http://dp1-l3:2223 ; echo
truefalse
$ 

Here is stylesheet isXPath1.xsl:

 

Hermann _{<myBlog/> <myTweets/> | <GraphvizFiddle/> | <xqib/> | <myCE/> <myFrameless/>}

Previous posting was on XSLT number precision
 
In posting xs:decimal()
https://www.ibm.com/developerworks/mydeveloperworks/blogs/HermannSW/entry/xs_decimal19
it was discussed that xs:decimal() has to be applied to an atomic type, and a solution was provided allowing to apply xs:decimal() to a nodeset.
In addition it was mentioned that "XSLT 2.0" needs to be selected as "XSLT Version" in DataPower service's XML Manager's Compile Options Policy.
 
The XSLT 2.0 spec requires at least 18 digit precision for xs:decimal:
http://www.w3.org/TR/xslt20/#limits
 
DataPower xs:decimal  supports precision of 18 digits, which can be seen by the following simple experiments.
The last three samples produce the following error messages in the log:

• long4.xml (overflow)
  mpgw (coproc2): Execution of 'xa35://tmp/temp_00165' aborted: xa35://tmp/temp_00165:13: decimal overflow
  
• long5.xml (number too long)
  mpgw (coproc2): Execution of 'xa35://tmp/temp_00165' aborted: xa35://tmp/temp_00165:11: cannot convert value to decimal
  
• long6.xml (number too long)
  mpgw (coproc2): Execution of 'xa35://tmp/temp_00165' aborted: xa35://tmp/temp_00165:11: cannot convert value to decimal
  

$ cat long[1-6].xml
<n>123456789012345678.876543210987654321</n>
<n>899999999999999999.999999999999999998</n>
<n>799999999999999999.999999999999999999</n>
<n>899999999999999999.999999999999999999</n>
<n>.1234567890123456789</n>
<n>1234567890123456789</n>
$ 
$ java coproc2 decimalDemo.xsl long1.xml http://dp3-l3:2223
 
.   123456789012345678.876543210987654321
+   100000000000000000.000000000000000001
=   223456789012345678.876543210987654322
$ 
$ java coproc2 decimalDemo.xsl long2.xml http://dp3-l3:2223
 
.   899999999999999999.999999999999999998
+   100000000000000000.000000000000000001
=   999999999999999999.999999999999999999
$ 
$ java coproc2 decimalDemo.xsl long3.xml http://dp3-l3:2223
 
.   799999999999999999.999999999999999999
+   100000000000000000.000000000000000001
=   900000000000000000
$ 
$ cat decimalDemo.xsl 
<xsl:stylesheet version="1.0" 
  xmlns:xsl="http://www.w3.org/1999/XSL/Transform" 
  xmlns:xs="http://www.w3.org/2001/XMLSchema"
>
  <xsl:output method="text"/>
 
  <xsl:variable name="add18d18" 
    select=" xs:decimal('100000000000000000.000000000000000001')"/>
 
  <xsl:template match="/">
.   <xsl:value-of select="xs:decimal(.)"/>
+   <xsl:value-of select="$add18d18"/>
=   <xsl:value-of select="xs:decimal(.) + $add18d18"/>
  </xsl:template>
</xsl:stylesheet>
$

 
Hermann.

This posting is on precision of numbers in XSLT 1.0 (XPath 1.0).
 
From the XPath 1.0 specification: http://www.w3.org/TR/xpath/#numbers

3.5 Numbers

 
Here you may find the details on double-precision:  http://en.wikipedia.org/wiki/Double_precision
 
Below you can see the output of DataPower, xsltproc, xalan and saxon XSLT processors for numbers with 15 to 18 digits.
Reported is the length, the conversion of the input string to number (by XSLT core function number()) as well as the original input string.
The last 16 digit number is the lowest (positive) integer with precision loss:

$ curl --data-binary @precesion.xml http://dp3-l3.boeblingen.de.ibm.com:12345
 len  number()              [original]
  15: 123456789012345 [123456789012345]
  16: 1234567890123456 [1234567890123456]
  17: 12345678901234568 [12345678901234567]
  18: 123456789012345680 [123456789012345678]
  16: 9007199254740992 [9007199254740993]
$ 
$ xsltproc precesion.xsl precesion.xml
 len  number()              [original]
  15:  1.23456789012345e+14 [123456789012345]
  16:  1.23456789012346e+15 [1234567890123456]
  17:  1.23456789012346e+16 [12345678901234567]
  18:  1.23456789012346e+17 [123456789012345678]
  16:  9.00719925474099e+15 [9007199254740993]
$ 
$ xalan precesion.xsl precesion.xml
 len  number()              [original]
  15: 123456789012345 [123456789012345]
  16: 1234567890123456 [1234567890123456]
  17: 12345678901234568 [12345678901234567]
  18: 123456789012345680 [123456789012345678]
  16: 9007199254740992 [9007199254740993]
$ 
$ saxon precesion.xsl precesion.xml
 len  number()              [original]
  15: 1.23456789012345E14 [123456789012345]
  16: 1.234567890123456E15 [1234567890123456]
  17: 1.2345678901234568E16 [12345678901234567]
  18: 1.2345678901234568E17 [123456789012345678]
  16: 9.007199254740992E15 [9007199254740993]
$ 

 
 
Find here the sample input file as well as the stylesheet used:

$ cat precesion.xml 
<data>
  <i>123456789012345</i>
  <i>1234567890123456</i>
  <i>12345678901234567</i>
  <i>123456789012345678</i>
  <i>9007199254740993</i>
</data>
$ 
$ cat precesion.xsl 
<xsl:stylesheet version="1.0" 
  xmlns:xsl="http://www.w3.org/1999/XSL/Transform" 
>
  <xsl:output method="text"/>
 
  <xsl:template match="i">
    <xsl:value-of 
      select="concat(string-length(.),': ',number(.),' [',.,']')"/>
  </xsl:template>
 
  <xsl:template match="/">
    <xsl:text> len  number()              [original]</xsl:text>
 
    <xsl:apply-templates />
  </xsl:template>
</xsl:stylesheet>
$

 
Hermann.