Hello, unfortunately our queries are far from being simple and they require all parameters we pass. What I provided it's a mere trivial example of what we are facing. Anyway, regarding function testFast1, what if I use the dynamic argument I pass, like:
declare function xbpr:testFast1($objectId as xs:string?){ let $docName := $cxnDefsDocName let $conn_typeof_target := doc($docName)/CxnDefs/CxnDef[@type="RdfsType" *and @source=$objectId*]/@target return $conn_typeof_target };
I thought it should fall into the same situation like testSlow but it does not, it still runs fast.
William
On 01/12/2011 10:43 AM, Leonard Wörteler wrote:
Hi William,
Am 12.01.2011 09:22, schrieb William Sandri:
We are migrating our product from Berkeley Xml DB to BaseX because of overall best performances
nice to hear!
I already took a look at the query info but I obviously cannot say what it is going on in the compilation process.
I looked into your query and I think I figured out what's going on:
In BaseX there are several optimization rules for preevaluating constant subexpressions. The relevant ones are:
- Function calls are evaluated if all arguments are evaluated
- FLOWR constructs are eliminated if they don't use iteration
This leads to optimization of the first two functions, but not the last one:
declare function xbpr:testFast1($objectId as xs:string?){ let $docName := $cxnDefsDocName let $conn_typeof_target := doc($docName)/CxnDefs /CxnDef[@type="RdfsType"]/@target return $conn_typeof_target };
Here the argument is dynamic, but it isn't used in the function body. So the function body is preevaluated and calling the function is nearly free performance-wise.
The second function
declare function xbpr:testFast2($docName as xs:string?){ let $conn_typeof_target := doc($docName)/CxnDefs /CxnDef[@type="RdfsType"]/@target return $conn_typeof_target };
is called only with constant arguments, so it can be preevaluated completely.
The slow function
declare function xbpr:testSlow($docName as xs:string?, $objectId as xs:string?){ let $conn_typeof_target := doc($docName)/CxnDef /CxnDef[@type="RdfsType"]/@target return $conn_typeof_target };
prevents both optimizations as it a) is called with the dynamic argument $objectId (which it ignores) b) depends on it's arguments, so the body cant be evaluated in advance
We'll refine the optimization of functions so that they are preevaluated if all arguments are either constant or ignored. Until then you could simply remove unused arguments from your functions and/or separate constant subexpressions in other ways to help the optimizer.
I hope this helps, cheers Leo