Saxon

In 11.x, GeneralComparison.typeCheck() line 305 rewrites the comparison to a value comparison like this:

                    Expression vun = makeCompareUntypedToNumeric(getLhsExpression(), getRhsExpression(), singletonOperator);
                    return vun.typeCheck(visitor, contextInfo);

In 12.x this has been changed to:

                    setAtomicComparer(new UntypedNumericComparer());
                    return this;

Git Blame dates this as 19/08/22 and attributes it to bytecode changes, I suspect a bug fix mixed into the same commit as something else.

I've done a fair bit of digging in the history and I can't find any record of what motivated this code change on 2022-08-19. So I'm going to have to deal with it from first principles.

Coincidental bug fixes are not the worst ;)

…must have been a heisen(de)bugger!

Thanks for the update! I checked again and I think it might be the influence of other Jar files which I included in the project which is pretty strange. When I remove the jar file of eXist-core the problem indeed disappeared. Thanks again!

Hi, today I found another case which seems to be very similar to this issue about non-existing attributes (I verified through the command line that this is reproducible for Saxon-HE 12.2) XML:

<Q1/>

XPath:

//Q1[(@p1 ! (. > 1)) = false()]

Saxon returned empty result set. Should return Q1.

This is the what I executed from the cmd:

java -cp saxon-he-12.2.jar net.sf.saxon.Query -t -s:test.xml -q:xq.xq -o:out.txt

In out:

<?xml version="1.0" encoding="UTF-8"?>

Perhaps there is another part of the source code where this bug still exists?

Shuxin Li wrote in #note-12:

Hi, today I found another case which seems to be very similar to this issue about non-existing attributes (I verified through the command line that this is reproducible for Saxon-HE 12.2) XML:

<Q1/>

XPath:

//Q1[(@p1 ! (. > 1)) = false()]

Saxon returned empty result set. Should return Q1.

Can you explain why?

The predicate in my view evaluates to false (as () = false() is false()) so //Q1[false()] correctly doesn't select anything.

I agree with Martin's analysis.

Note however that if XPath 1.0 compatibility mode is enabled, comparing an empty sequence to false() returns true, whereas without 1.0 compatibility mode, it returns false. Of course an XPath 1.0 processor doesn't understand the "!" operator, but a 2.0 processor running in 1.0 mode will give a different result.

Hi Martin, I'm not very sure about the semantics because I didn't actually find where it is documented.

I derived this from the discussion here: https://github.com/BaseXdb/basex/issues/2212

It was mentioned that () >= -1 returns false(), therefore I thought that in this case (. > 1) is (() > 1) should return false(), and false() = false() should return true(). So the node should be selected. I don't know if this is correct?

For in this test BaseX did return the node as expected, and I thought it should be the case.

Shuxin Li wrote in #note-16:

Hi Martin, I'm not very sure about the semantics because I didn't actually find where it is documented.

I derived this from the discussion here: https://github.com/BaseXdb/basex/issues/2212

It was mentioned that () >= -1 returns false(), therefore I thought that in this case (. > 1) is (() > 1) should return false(), and false() = false() should return true(). So the node should be selected. I don't know if this is correct?

As @p1 gives the empty sequence the result of @p1 ! (. > 1) is the empty sequence.

Hi Martin, I could understand that if take map as a streaming process, empty sequence will result in an empty sequence. So is it correct that it's the map that changed the situation? Still it seems a bit confusing though, for in previous case () >= 1 returns false() and here () > 1 returns the empty sequence.

I get the idea that with map Saxon takes the input as a sequence, and if no item is in the sequence it will result in an empty sequence instead of giving the empty sequence as an input to the following functions. That makes a lot of sense! Thank you very much.

An expression using the "=" operator is called a General Comparison, and the rules are found at

https://www.w3.org/TR/xpath-31/#id-general-comparisons

To summarise, if you compare S = T when S and T are sequences, the comparison is true if there is an item $s in S and an item $t in T such that $s equals $t. That means if either S or T is an empty sequence, the result is necessarily false: () = X is false regardless what X is.

So given the expression

`(@p1 ! (. > 1)) = false()`

@p1 is an empty sequence

Therefore @p1 ! X is an empty sequence (regardless what X is)

So you are comparing an empty sequence with false(), which is always false.

Thank you for the detailed explanation! I get that :)