net.sf.saxon.expr

Class Optimizer

public class Optimizer extends Object implements Serializable

This class performs optimizations that vary between different versions of the Saxon product. The optimizer is obtained from the Saxon Configuration. This class is the version used in Saxon-B, which in most cases does no optimization at all: the methods are provided so that they can be overridden in Saxon-EE.
Field Summary
protected Configurationconfig
static intFULL_OPTIMIZATION
static intNO_OPTIMIZATION
Constructor Summary
Optimizer(Configuration config)
Create an Optimizer.
Method Summary
ExpressionconvertPathExpressionToKey(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().
FilterExpressionconvertToFilterExpression(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].
ExpressionextractGlobalVariables(Expression body, ExpressionVisitor visitor)
Extract subexpressions from the body of a function that can be evaluated as global variables
ConfigurationgetConfiguration()
Get the Saxon configuration object
intgetOptimizationLevel()
Get the optimization level
intisIndexableFilter(Expression filter)
Test whether a filter predicate is indexable.
booleanisVariableReplaceableByDot(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 ".".
ValuemakeClosure(Expression expression, int ref, XPathContext context)
Make a Closure, given the expected reference count
ExpressionmakeConditionalDocumentSorter(DocumentSorter sorter, PathExpression path)
Make a conditional document sorter.
BinaryExpressionmakeGeneralComparison(Expression p0, int op, Expression p1, boolean backwardsCompatible)
Create a GeneralComparison expression
ValueRepresentationmakeIndexedValue(SequenceIterator iter)
Create an indexed value
RuleTargetmakeInversion(Template template, NodeTest nodeTest)
Generate the inversion of the expression comprising the body of a template rules.
ValueRepresentationmakeSequenceExtent(Expression expression, int ref, XPathContext context)
Make a SequenceExtent, given the expected reference count
ExpressionmakeStreamingApplyTemplates(ApplyTemplates inst)
Make a streaming applyTemplates instruction.
ExpressionoptimizeCopy(Expression select)
Attempt to optimize a copy operation.
ExpressionpromoteExpressionsToGlobal(Expression body, ExpressionVisitor visitor, boolean notTopLevel)
Identify expressions within a function or template body that can be promoted to be evaluated as global variables.
voidsetOptimizationLevel(int level)
Set the optimization level
voidtrace(String message, Expression exp)
Trace optimization actions
voidtrace(String message)
Trace optimization actions
ExpressiontryIndexedFilter(FilterExpression f, ExpressionVisitor visitor, boolean indexFirstOperand)
Try converting a filter expression to a call on the key function.
ExpressiontryInlineFunctionCall(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
ExpressiontrySwitch(Choose choose, StaticContext env)
Try to convert a Choose expression into a switch

Field Detail

config

protected Configuration config

FULL_OPTIMIZATION

public static final int FULL_OPTIMIZATION

NO_OPTIMIZATION

public static final int NO_OPTIMIZATION

Constructor Detail

Optimizer

public Optimizer(Configuration config)
Create an Optimizer.

Parameters: config the Saxon configuration

Method Detail

convertPathExpressionToKey

public 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(). If not, return null.

Parameters: pathExp The path expression to be converted. visitor The expression visitor

Returns: the optimized expression, or null if no optimization is possible

convertToFilterExpression

public 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]. This is possible whenever the predicate is non-positional. The conversion is useful in the case where the path expression appears inside a loop, where the predicate depends on the loop variable but a/b/c does not.

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

extractGlobalVariables

public Expression extractGlobalVariables(Expression body, ExpressionVisitor visitor)
Extract subexpressions from the body of a function that can be evaluated as global variables

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

getConfiguration

public Configuration getConfiguration()
Get the Saxon configuration object

Returns: the configuration

getOptimizationLevel

public int getOptimizationLevel()
Get the optimization level

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

isIndexableFilter

public int isIndexableFilter(Expression filter)
Test whether a filter predicate is indexable.

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

isVariableReplaceableByDot

public 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 ".". This is true of there are no references to the variable within a filter predicate or on the rhs of a "/" operator.

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

makeClosure

public Value makeClosure(Expression expression, int ref, XPathContext context)
Make a Closure, given the expected reference count

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

makeConditionalDocumentSorter

public Expression makeConditionalDocumentSorter(DocumentSorter sorter, PathExpression path)
Make a conditional document sorter. This optimization is attempted when a DocumentSorter is wrapped around a path expression

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

makeGeneralComparison

public BinaryExpression makeGeneralComparison(Expression p0, int op, Expression p1, boolean backwardsCompatible)
Create a GeneralComparison expression

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

makeIndexedValue

public ValueRepresentation makeIndexedValue(SequenceIterator iter)
Create an indexed value

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

makeInversion

public RuleTarget makeInversion(Template template, NodeTest nodeTest)
Generate the inversion of the expression comprising the body of a template rules. Supported in Saxon-EE only

Parameters: template the template to be inverted nodeTest the static item type of the context node of the template

makeSequenceExtent

public ValueRepresentation makeSequenceExtent(Expression expression, int ref, XPathContext context)
Make a SequenceExtent, given the expected reference count

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

makeStreamingApplyTemplates

public Expression makeStreamingApplyTemplates(ApplyTemplates inst)
Make a streaming applyTemplates instruction. Supported in Saxon-EE only

Parameters: inst the unoptimized applyTemplates instruction

optimizeCopy

public Expression optimizeCopy(Expression select)
Attempt to optimize a copy operation. Return null if no optimization is possible.

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

promoteExpressionsToGlobal

public 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.

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

setOptimizationLevel

public void setOptimizationLevel(int level)
Set the optimization level

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

trace

public void trace(String message, Expression exp)
Trace optimization actions

Parameters: message the message to be displayed exp the expression after being rewritten

trace

public void trace(String message)
Trace optimization actions

Parameters: message the message to be displayed

tryIndexedFilter

public Expression tryIndexedFilter(FilterExpression f, ExpressionVisitor visitor, boolean indexFirstOperand)
Try converting a filter expression to a call on the key function. Return the supplied expression unchanged if not possible

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

tryInlineFunctionCall

public 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

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

trySwitch

public Expression trySwitch(Choose choose, StaticContext env)
Try to convert a Choose expression into a switch

Parameters: choose the Choose expression env the static context

Returns: the result of optimizing this (the original expression if no optimization was possible)