Class Optimizer

  • All Implemented Interfaces:
    java.io.Serializable

    public class Optimizer
    extends java.lang.Object
    implements java.io.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.
    See Also:
    Serialized Form
    • Constructor Detail

      • Optimizer

        public Optimizer​(Configuration config)
        Create an Optimizer.
        Parameters:
        config - the Saxon configuration
    • Method Detail

      • getConfiguration

        public Configuration getConfiguration()
        Get the Saxon configuration object
        Returns:
        the configuration
      • 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
      • 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
        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
        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.
        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
        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.
        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.
        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
      • 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
      • 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
      • 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
        Throws:
        XPathException
      • 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)
      • 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
        Throws:
        XPathException
      • trace

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

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