com.saxonica.extra
Class OptimizerSA

java.lang.Object
  net.sf.saxon.expr.Optimizer
      com.saxonica.extra.OptimizerSA

All Implemented Interfaces:

Serializable

public class OptimizerSA
extends Optimizer

This class doesn't actually do any optimization itself, despite the name. Rather, it is intended to act as a factory for implementation classes that perform optimization, so that the appropriate level of optimization can be selected.

See Also:

Serialized Form

Constructor Summary

OptimizerSA(Configuration config)
Create the Saxon-SA 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
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	optimizeStreamingCopy(Expression select) Given a select expression, determine whether it is a candidate for sequential processing, and if so, return a SequentialCopy expression that does the work.
Expression	promoteExpressionsToGlobal(Expression body, ExpressionVisitor visitor) Identify expressions within a function or template body that can be promoted to be evaluated as global variables.
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

Methods inherited from class net.sf.saxon.expr.Optimizer

getConfiguration, trace, trace

Methods inherited from class java.lang.Object

equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

OptimizerSA

public OptimizerSA(Configuration config)

Create the Saxon-SA optimizer

Parameters:

config - the Saxon-SA configuration

Method Detail

makeGeneralComparison

public BinaryExpression makeGeneralComparison(Expression p0,
                                              int op,
                                              Expression p1,
                                              boolean backwardsCompatible)

Create a GeneralComparison expression

Overrides:

makeGeneralComparison in class Optimizer

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

optimizeCopy

public Expression optimizeCopy(Expression select)
                        throws XPathException

Attempt to optimize a copy operation. Return null if no optimization is possible.

Overrides:

optimizeCopy in class Optimizer

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

Throws:

XPathException

optimizeStreamingCopy

public Expression optimizeStreamingCopy(Expression select)
                                 throws XPathException

Given a select expression, determine whether it is a candidate for sequential processing, and if so, return a SequentialCopy expression that does the work.

To qualify, the select expression must be a path expression that starts with a call on doc() or document(), and whose subsequent steps are all axis steps using the child, descendant, and attribute axes only; there must be no predicates; it must match either elements only, or attributes only

Parameters:

select - the select expression to be examined

Returns:

either null if no optimization is possible, or a StreamingCopy expression

Throws:

XPathException

makeClosure

public Value makeClosure(Expression expression,
                         int ref,
                         XPathContext context)
                  throws XPathException

Make a Closure, given the expected reference count

Overrides:

makeClosure in class Optimizer

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

Throws:

XPathException

makeSequenceExtent

public ValueRepresentation makeSequenceExtent(Expression expression,
                                              int ref,
                                              XPathContext context)
                                       throws XPathException

Make a SequenceExtent, given the expected reference count

Overrides:

makeSequenceExtent in class Optimizer

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

Throws:

XPathException

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.

Overrides:

convertPathExpressionToKey in class Optimizer

Parameters:

pathExp - The path expression to be converted.

visitor - The expression visitor

Returns:

the optimized expression, or null if no optimization is possible

Throws:

XPathException

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

Overrides:

tryIndexedFilter in class Optimizer

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

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.

Overrides:

convertToFilterExpression in class Optimizer

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

Throws:

XPathException

isIndexableFilter

public int isIndexableFilter(Expression filter)

Test whether a filter predicate is indexable.

Overrides:

isIndexableFilter in class Optimizer

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

makeIndexedValue

public ValueRepresentation makeIndexedValue(SequenceIterator iter)
                                     throws XPathException

Create an indexed value

Overrides:

makeIndexedValue in class Optimizer

Parameters:

iter - the iterator that delivers the sequence of values to be indexed

Returns:

the indexed value

Throws:

XPathException

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

Overrides:

makeConditionalDocumentSorter in class Optimizer

Parameters:

sorter - an expression that sorts and deduplicates its operand

path - the path expression that is the operand of the sorter

Returns:

either the original sorter, if no optimization is possible; or a ConditionalSorter which first tests a condition, and performs the sort if the condition is true, or returns the unsorted operand if not. In practice the condition is always a test whether the first item in the path expression contains more than one item

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

Overrides:

tryInlineFunctionCall in class Optimizer

Parameters:

functionCall - the functionCall expression

visitor - the expression visitor

contextItemType - the static type of the context item

Returns:

either the original expression unchanged, or an expression that consists of the inlined function body, with all function parameters bound as required.

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.

Overrides:

promoteExpressionsToGlobal in class Optimizer

Parameters:

body - the body of the template or function

visitor - the expression visitor

Returns:

the expression after subexpressions have been promoted to global variables

Throws:

XPathException

trySwitch

public Expression trySwitch(Choose choose,
                            StaticContext env)

Try to convert a Choose expression into a switch

Overrides:

trySwitch in class Optimizer

Parameters:

choose - the Choose expression

env - the static context

Returns:

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

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

Overrides:

extractGlobalVariables in class Optimizer

Parameters:

body - an expression with no dependencies other than on global variables (already checked by the caller)

Returns:

a reference to the new global variable if a variable has been created, or null if not

Throws:

XPathException