XQuery for loop producing duplicate results

Question

I'm using XQuery to analyze two sets of test results that have the same XML structure. The function below creates a new set of elements that are individual comparisons of the two result set's test-cases. For each test-case there should be a 1-1 relationship for the two sets yet my code is producing sometimes 8 comparisions and I can't figure out why!

Here's my input XML used for both sets with different data (abbreviated for example):

 <tests>
  <test-group name="TestA">
    <test-case name="CaseA1" success="true"/>
    <test-case name="CaseA2" success="false"/>
    <test-case name="CaseA3" success="true"/>
  </test-group>
  <test-group name="TestB">
    <test-case name="CaseB1" success="false"/>
    <test-case name="CaseB2" success="false"/>
    <test-case name="CaseB3" success="true"/>
  </test-group>
  <test-group name="TestC">
    <test-case name="CaseC1" success="false"/>
    <test-case name="CaseC2" success="false"/>
    <test-case name="CaseC3" success="true"/>
  </test-group>
</tests>

Sample output:

 <test-state delta1="15" delta2="false" isPass="true" fixture="TestA" case="CaseA1"/>
 <test-state delta1="12" delta2="true" isPass="false" fixture="TestA" case="CaseA1"/>
 <test-state delta1="5" delta2="false" isPass="true" fixture="TestA" case="CaseA1"/>
 <test-state delta1="15" delta2="false" isPass="true" fixture="TestC" case="CaseC1"/>
 <test-state delta1="12" delta2="true" isPass="false" fixture="TestC" case="CaseC1"/>
 <test-state delta1="5" delta2="false" isPass="true" fixture="TestC" case="CaseC1"/>

Here is my Xquery (modified for example):

declare function app:runReport() {
    let $new-run := collection('collection1')
    let $old-run := collection('collection2')    
    return 
<report> 
    {         
    for $new-case in $new-run//test-case,
        $old-case in $old-run//test-case
        where $new-case/@name = $old-case/@name and $new-case/../@name = $old-case/../@name
            return
                let $new-msg := xs:string($new-case/message)
                let $old-msg := xs:string($old-case/message)
                let $new-len := string-length($new-msg)
                let $old-len := string-length($old-msg)
                let $msg-dif := $new-len - $old-len

                let $delta1 := fn:compare(xs:string($new-case/@success),xs:string($old-case/@success)) = 0
                let $delta2 := abs($msg-dif)
                return        
                   <test-state 
                          delta1="{$delta1}"
                          delta2="{$delta2}"
                          isPass="{$new-case/@success}"
                         fixture="{$new-case/../@name}"
                            case="{$new-case/@name}"
                            path="unknownPath"/>
    }        
</report>
};

It appears to me that its making permutations of every combination between $new-case and $old-case but I have no idea why. I would try to filter the duplicates out but they are not exact duplicates, it seems to use $old-case in place of $new-case sometimes.

Answer 1

It appears to me that its making permutations of every combination between $new-case and $old-case

This is exactly what's happening, by virtue of the structure of your for. For example:

for $x in (1, 2, 3), $y in ('a', 'b', 'c')
return <z>{$x, $y}</z>

=>

<z>1 a</z>
<z>1 b</z>
<z>1 c</z>
<z>2 a</z>
<z>2 b</z>
<z>2 c</z>
<z>3 a</z>
<z>3 b</z>
<z>3 c</z>

Instead, you can just look up the matching old-test:

for $new-case in $new-run//test-case
let $old-case := $old-run//test-case[@name = $new-case/@name]
return
...

Answer 2

At a guess, your two inputs differ from the sample you have shown us in ways that affect the crucial comparison $new-case/@name = $old-case/@name and $new-case/../@name = $old-case/../@name -- in either the new collection or the old, or both, the combination of ../@name and ./@name is not unique.

To find duplicates in the data, I'd run a query something like this:

let $new-run := collection('collection1'),
    $old-run := collection('collection2')    
for $name in distinct-values(
        for $tc in ($new-run | $old-run)//test-case/@name
        return concat($tc/../@name,' || ',$tc/@name) 
    )
let $old := $old-run//test-case
            [concat(../@name,' || ', @name) = $name],
    $new := $new-run//test-case
            [concat(../@name,' || ', @name) = $name]
where count($old) gt 1 
   or count($new) gt 1
return <duplicate-id name="{$name}"
                     old-count="{count($old)}"
                     new-count="{count($new)}"/>