net.sf.saxon.expr

Class Optimizer

Implemented Interfaces:
Serializable

public class Optimizer
extends java.lang.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-SA.

Field Summary

protected Configuration
config

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
isIndexableFilter(Expression filter)
Test whether a filter predicate is indexable.
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
ValueRepresentation
makeSequenceExtent(Expression expression, int ref, XPathContext context)
Make a SequenceExtent, given the expected reference count
Expression
optimizeCopy(Expression select)
Attempt to optimize a copy operation.
Expression
promoteExpressionsToGlobal(Expression body, ExpressionVisitor visitor)
Identify expressions within a function or template body that can be promoted to be evaluated as global variables.
void
trace(String message)
Trace optimization actions
void
trace(String message, Expression exp)
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

Field Details

config

protected Configuration config

Constructor Details

Optimizer

public Optimizer(Configuration config)
Create an Optimizer.
Parameters:
config - the Saxon configuration

Method Details

convertPathExpressionToKey

public Expression convertPathExpressionToKey(PathExpression pathExp,
                                             ExpressionVisitor visitor)
            throws XPathException
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)
            throws XPathException
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)
            throws XPathException
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

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

makeClosure

public Value makeClosure(Expression expression,
                         int ref,
                         XPathContext context)
            throws XPathException
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)
            throws XPathException
Create an indexed value
Parameters:
iter - the iterator that delivers the sequence of values to be indexed
Returns:
the indexed value

makeSequenceExtent

public ValueRepresentation makeSequenceExtent(Expression expression,
                                              int ref,
                                              XPathContext context)
            throws XPathException
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

optimizeCopy

public Expression optimizeCopy(Expression select)
            throws XPathException
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)
            throws XPathException
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
Returns:
the expression after subexpressions have been promoted to global variables

trace

public void trace(String message)
Trace optimization actions
Parameters:
message - the message to be displayed

trace

public void trace(String message,
                  Expression exp)
Trace optimization actions
Parameters:
message - the message to be displayed
exp - the expression after being rewritten

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)