PowerBuilder

XML Path Performance Optimizations

See more XML Examples

Discusses some important things to know about using Chilkat paths in the Chilkat XML API. PowerBuilder

integer li_rc
integer li_Success
oleobject loo_Xml
integer li_LicCount
string s
integer i

li_Success = 0

loo_Xml = create oleobject
li_rc = loo_Xml.ConnectToNewObject("Chilkat.Xml")
if li_rc < 0 then
    destroy loo_Xml
    MessageBox("Error","Connecting to COM object failed")
    return
end if

// Let's load XML containing the following:

// <?xml version="1.0" encoding="utf-8"?>
// <xyz>
//     <licenses>
//         <license>
//             <id>1234</id>
//         </license>
//         <license>
//             <id>1234</id>
//         </license>
// ...
// My sample XML contains 64,000 "license" nodes ..
// ...
//         <license>
//             <id>1234</id>
//         </license>
//         <license>
//             <id>1234</id>
//         </license>
//     </licenses>
// </xyz>
// 
li_Success = loo_Xml.LoadXmlFile("qa_output/large.xml")
if li_Success <> 1 then
    Write-Debug loo_Xml.LastErrorText
    destroy loo_Xml
    return
end if

// Iterating over the individual "license" nodes with this code snippet is
// extremely slow:
li_LicCount = loo_Xml.NumChildrenHavingTag("licenses|license")
Write-Debug "license count = " + string(li_LicCount)

i = 0
// If "10" is changed to licCount, then it becomes apparent that this loop gets slower with each iteration.
do while i < 10
    loo_Xml.I = i
    s = loo_Xml.GetChildContent("licenses|license[i]|id")
    Write-Debug string(i) + ": " + s
    i = i + 1
loop

// The reason it is extremely slow is that the "license[i]" part of the path passed to GetChildContent
// says: find the i'th child of "licenses" having the tag "license".  Chilkat cannot assume that all
// children of an XML node have the same tag.  Therefore it's not possible to directly access the i'th child.
// Internally, Chilkat must start at the 1st child and iterate until it reaches the i'th child having the
// tag "license".

// For example, imagine if the XML was like this:

// <?xml version="1.0" encoding="utf-8"?>
// <xyz>
//     <licenses>
//         <license>
//             <id>1234</id>
//         </license>
//         <somethingElse>
//             <a>abc</a>
//         </somethingElse>
//         <license>
//             <id>1234</id>
//         </license>
// ...

// In the above XML, the 1st "license" is the 1st child of "licenses", but the 2nd "license"
// is the 3rd child of "licenses".

// If you already know that all children have the same tag, there is a shortcut that allows
// for direct access to that child.  Just leave off the tag name, like this:

i = 0
// If "10" is changed to licCount, then we can see the time for each loop is the same, and it's fast.
do while i < 10
    loo_Xml.I = i
    s = loo_Xml.GetChildContent("licenses|[i]|id")
    Write-Debug string(i) + ": " + s
    i = i + 1
loop

// When we pass just the index "[i]", we're saying: Get the i'th child regardless of tag.
// This is extremely fast because internally we can just access the i'th child directly.

// Another performance improvement is to call NumChildrenAt rather than NumChildrenHavingTag.
// For example:
li_LicCount = loo_Xml.NumChildrenAt("licenses")
Write-Debug "licCount = " + string(li_LicCount)

// NumChildrenAt returns the total number of children at the tag path.  If we already know
// all children will have the same tag, we can just get the count


destroy loo_Xml