net.sf.saxon.expr
Class Optimizer

java.lang.Object
  net.sf.saxon.expr.Optimizer

All Implemented Interfaces:

Serializable

Direct Known Subclasses:

OptimizerSA

public class Optimizer
extends Object
implements Serializable

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

Optimizer(Configuration config)

Method Summary

Expression	convertPathExpressionToKey(PathExpression pathExp, StaticContext env) 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].
Configuration	getConfiguration()
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
BinaryExpression	makeGeneralComparison(Expression p0, int op, Expression p1, boolean backwardsCompatible) Create a GeneralComparison expression
ValueRepresentation	makeIndexedValue(SequenceIterator iter) Create an indexed value
Expression	optimizeCopy(Expression select) Attempt to optimize a copy operation.
Expression	tryIndexedFilter(FilterExpression f, StaticContext env, boolean indexedOperand) Try converting a filter expression to a call on the key function.

Methods inherited from class java.lang.Object

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

Constructor Detail

Optimizer

public Optimizer(Configuration config)

Method Detail

getConfiguration

public Configuration getConfiguration()

makeGeneralComparison

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

Create a GeneralComparison expression

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

Throws:

XPathException

makeClosure

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

Make a Closure, given the expected reference count

Throws:

XPathException

convertPathExpressionToKey

public Expression convertPathExpressionToKey(PathExpression pathExp,
                                             StaticContext env)
                                      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.

Throws:

XPathException

tryIndexedFilter

public Expression tryIndexedFilter(FilterExpression f,
                                   StaticContext env,
                                   boolean indexedOperand)

Try converting a filter expression to a call on the key function. Return the supplied expression unchanged if not possible

convertToFilterExpression

public FilterExpression convertToFilterExpression(PathExpression pathExp,
                                                  TypeHierarchy th)
                                           throws StaticError

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

Returns:

the resulting filterexpression if conversion is possible, or null if not

Throws:

StaticError

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

makeIndexedValue

public ValueRepresentation makeIndexedValue(SequenceIterator iter)
                                     throws XPathException

Create an indexed value

Throws:

XPathException