net.sf.saxon.expr
public class Optimizer extends Object implements Serializable
Field Summary | |
---|---|
protected Configuration | config |
static int | FULL_OPTIMIZATION |
static int | NO_OPTIMIZATION |
Constructor Summary | |
---|---|
Optimizer(Configuration config)
Create an Optimizer. |
Method Summary | |
---|---|
Expression | convertPathExpressionToKey(PathExpression pathExp, ExpressionVisitor visitor)
Examine a path expression to see whether it can be replaced by a call on the key() function;
if so, generate an appropriate key definition and return the call on key(). |
FilterExpression | convertToFilterExpression(PathExpression pathExp, TypeHierarchy th)
Convert a path expression such as a/b/c[predicate] into a filter expression
of the form (a/b/c)[predicate]. |
Expression | extractGlobalVariables(Expression body, ExpressionVisitor visitor)
Extract subexpressions from the body of a function that can be evaluated
as global variables |
Configuration | getConfiguration()
Get the Saxon configuration object |
int | getOptimizationLevel()
Get the optimization level |
int | isIndexableFilter(Expression filter)
Test whether a filter predicate is indexable. |
boolean | isVariableReplaceableByDot(Expression exp, Binding[] binding)
Determine whether it is possible to rearrange an expression so that all references to a given
variable are replaced by a reference to ".". |
Value | makeClosure(Expression expression, int ref, XPathContext context)
Make a Closure, given the expected reference count |
Expression | makeConditionalDocumentSorter(DocumentSorter sorter, PathExpression path)
Make a conditional document sorter. |
BinaryExpression | makeGeneralComparison(Expression p0, int op, Expression p1, boolean backwardsCompatible)
Create a GeneralComparison expression |
ValueRepresentation | makeIndexedValue(SequenceIterator iter)
Create an indexed value |
RuleTarget | makeInversion(Template template, NodeTest nodeTest)
Generate the inversion of the expression comprising the body of a template rules.
|
ValueRepresentation | makeSequenceExtent(Expression expression, int ref, XPathContext context)
Make a SequenceExtent, given the expected reference count |
Expression | makeStreamingApplyTemplates(ApplyTemplates inst)
Make a streaming applyTemplates instruction. |
Expression | optimizeCopy(Expression select)
Attempt to optimize a copy operation. |
Expression | promoteExpressionsToGlobal(Expression body, ExpressionVisitor visitor, boolean notTopLevel)
Identify expressions within a function or template body that can be promoted to be
evaluated as global variables. |
void | setOptimizationLevel(int level)
Set the optimization level |
void | trace(String message, Expression exp)
Trace optimization actions |
void | trace(String message)
Trace optimization actions |
Expression | tryIndexedFilter(FilterExpression f, ExpressionVisitor visitor, boolean indexFirstOperand)
Try converting a filter expression to a call on the key function. |
Expression | tryInlineFunctionCall(UserFunctionCall functionCall, ExpressionVisitor visitor, ItemType contextItemType)
Replace a function call by the body of the function, assuming all conditions for inlining
the function are satisfied |
Expression | trySwitch(Choose choose, StaticContext env)
Try to convert a Choose expression into a switch |
Parameters: config the Saxon configuration
Parameters: pathExp The path expression to be converted. visitor The expression visitor
Returns: the optimized expression, or null if no optimization is possible
Parameters: pathExp the path expression to be converted th the type hierarchy cache
Returns: the resulting filterexpression if conversion is possible, or null if not
Parameters: body the body of the function
Returns: a reference to the new global variable if a variable has been created, or null if not
Returns: the configuration
Returns: the optimization level, between 0 (no optimization) and 10 (full optimization). Currently all values greater than zero have the same effect as full optimization
Parameters: filter the predicate expression
Returns: 0 if not indexable; +1 if the predicate is in the form expression=value; -1 if it is in the form value=expression
Parameters: exp the expression in question binding an array of bindings defining range variables; the method tests that there are no references to any of these variables within a predicate or on the rhs of "/"
Returns: true if the variable reference can be replaced
Parameters: expression the expression to be evaluated ref the (nominal) number of times the value of the expression is required context the XPath dynamic evaluation context
Returns: the constructed Closure
Parameters: sorter the document sorter path the path expression
Returns: the original sorter unchanged when no optimization is possible, which is always the case in Saxon-B
Parameters: p0 the first operand op the operator p1 the second operand backwardsCompatible true if XPath 1.0 backwards compatibility is in force
Returns: the constructed expression
Parameters: iter the iterator that delivers the sequence of values to be indexed
Returns: the indexed value
Throws: UnsupportedOperationException: this method should not be called in Saxon-B
Parameters: template the template to be inverted nodeTest the static item type of the context node of the template
Parameters: expression the expression to be evaluated ref the (nominal) number of times the value of the expression is required context the XPath dynamic evaluation context
Returns: the constructed Closure
Parameters: inst the unoptimized applyTemplates instruction
Parameters: select the expression that selects the items to be copied
Returns: null if no optimization is possible, or an expression that does an optimized copy of these items otherwise
Parameters: body the body of the template or function visitor the expression visitor notTopLevel if true, only promote the children of the supplied body expression, not the entire expression
Returns: the expression after subexpressions have been promoted to global variables
Parameters: level the optimization level, between 0 (no optimization) and 10 (full optimization). Currently all values greater than zero have the same effect as full optimization
Parameters: message the message to be displayed exp the expression after being rewritten
Parameters: message the message to be displayed
Parameters: f the filter expression to be converted visitor the expression visitor, which must be currently visiting the filter expression f indexFirstOperand true if the first operand of the filter comparison is to be indexed; false if it is the second operand
Returns: the optimized expression, or the unchanged expression f if no optimization is possible
Parameters: functionCall the functionCall expression visitor the expression visitor contextItemType the context item type
Returns: either the original expression unchanged, or an expression that consists of the inlined function body, with all function parameters bound as required. In Saxon-B, function inlining is not supported, so the original functionCall is always returned unchanged
Parameters: choose the Choose expression env the static context
Returns: the result of optimizing this (the original expression if no optimization was possible)