## com.saxonica.extra
Class OptimizerSA

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

All Implemented Interfaces:
  java.io.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

Field Summary

Fields inherited from class net.sf.saxon.expr.Optimizer
`config`

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
`clone, equals, finalize, 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`

Copyright (c) Saxonica Limited. All rights reserved.