Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## net.sf.saxon.expr.flwor
Class FLWORExpression

    java.lang.Object
      net.sf.saxon.expr.Expression
          net.sf.saxon.expr.flwor.FLWORExpression

All Implemented Interfaces:
  Serializable, SourceLocator, LocationProvider, SaxonLocator, InstructionInfo, Locator

    public class FLWORExpression

extends Expression

This class represents a FLWOR expression, evaluated using tuple streams

See Also:
  Serialized Form

Field Summary
`List<Clause>` | `clauses`
`Expression` | `returnClause`

Fields inherited from class net.sf.saxon.expr.Expression
`EFFECTIVE_BOOLEAN_VALUE, EVALUATE_METHOD, EVENT_FEED_METHOD, ITEM_FEED_METHOD, ITERATE_METHOD, locationId, MAX_SEQUENCE_LENGTH, MAX_STRING_LENGTH, PROCESS_METHOD, PUSH_SELECTION, staticProperties, UNBOUNDED_LOWER, UNBOUNDED_UPPER, WATCH_METHOD`

Constructor Summary
`FLWORExpression(List<Clause> clauses, Expression returnClause)`

Method Summary
`void` | `checkForUpdatingSubexpressions()` Check to ensure that this expression does not contain any inappropriate updating subexpressions.
`protected int` | `computeCardinality()` Compute the static cardinality of this expression
`Expression` | `copy()` Copy an expression.
`void` | `evaluatePendingUpdates(XPathContext context, PendingUpdateList pul)` Evaluate an updating expression, adding the results to a Pending Update List.
`void` | `explain(ExpressionPresenter out)` Diagnostic print of expression structure.
`List<Clause>` | `getClauseList()` Get the list of clauses of the FLWOR expression, in the order they are written.
`int` | `getEvaluationMethod()`
`ItemType` | `getItemType(TypeHierarchy th)` Determine the data type of the items returned by the expression.
`Expression` | `getReturnClause()` Get the return clause of the FLWOR expression
`boolean` | `hasLoopingSubexpression(Expression child)` Given an expression that is an immediate child of this expression, test whether the evaluation of the parent expression causes the child expression to be evaluated repeatedly
`boolean` | `hasLoopingVariableReference(Binding binding, Expression reference)`
`boolean` | `hasVariableBinding(Binding binding)` Determine whether a given variable binding belongs to this FLWOR expression
`boolean` | `isUpdatingExpression()` Determine whether this is an updating expression as defined in the XQuery update specification
`SequenceIterator<? extends Item>` | `iterate(XPathContext context)` Return an Iterator to iterate over the values of a sequence.
`Iterator<Expression>` | `iterateSubExpressions()` Get the immediate sub-expressions of this expression.
`Expression` | `optimize(ExpressionVisitor visitor, ExpressionVisitor.ContextItemType contextItemType)` Perform optimisation of an expression and its subexpressions.
`void` | `process(XPathContext context)` Process the instruction, without returning any tail calls
`Expression` | `promote(PromotionOffer offer, Expression parent)` Promote this expression if possible
`boolean` | `replaceSubExpression(Expression original, Expression replacement)` Replace one subexpression by a replacement subexpression
`void` | `replaceVariable(Optimizer opt, Expression seq)` Replace all references to the variable bound by this let expression, that occur within the action expression, with the given expression
`Expression` | `simplify(ExpressionVisitor visitor)` Simplify an expression.
`String` | `toString()` Display the expression as a string
`Expression` | `typeCheck(ExpressionVisitor visitor, ExpressionVisitor.ContextItemType contextItemType)` Perform type checking of an expression and its subexpressions.

Methods inherited from class net.sf.saxon.expr.Expression
`addToPathMap, adoptChildExpression, checkPermittedContents, computeDependencies, computeSpecialProperties, computeStaticProperties, doPromotion, dynamicError, effectiveBooleanValue, evaluateAsString, evaluateItem, explain, getCardinality, getColumnNumber, getColumnNumber, getConstructType, getContainer, getDependencies, getExecutable, getExpressionName, getHostLanguage, getImplementationMethod, getIntegerBounds, getIntrinsicDependencies, getLineNumber, getLineNumber, getLocationId, getLocationProvider, getObjectName, getProperties, getProperty, getPublicId, getSlotsUsed, getSpecialProperties, getSystemId, getSystemId, implementsStaticTypeCheck, isSubtreeExpression, isVacuousExpression, iterateEvents, iterateSameFocusSubExpressions, markTailFunctionCalls, resetLocalStaticProperties, setContainer, setEvaluationMethod, setFiltered, setFlattened, setLocationId, staticTypeCheck, suppressValidation, typeError`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`

Field Detail

### clauses

    public List<Clause> clauses

### returnClause

    public Expression returnClause

Constructor Detail

### FLWORExpression

    public FLWORExpression(List<Clause> clauses,
                           Expression returnClause)

Method Detail

### getClauseList

    public List<Clause> getClauseList()

  Get the list of clauses of the FLWOR expression, in the order they are written. This excludes the return clause

  Returns:
    the list of clauses

### hasLoopingSubexpression

    public boolean hasLoopingSubexpression(Expression child)

  Given an expression that is an immediate child of this expression, test whether the evaluation of the parent expression causes the child expression to be evaluated repeatedly

  Overrides:
    `hasLoopingSubexpression` in class `Expression`
  Parameters:
    `child` - the immediate subexpression
  Returns:
    true if the child expression is evaluated repeatedly

### getReturnClause

    public Expression getReturnClause()

  Get the return clause of the FLWOR expression

  Returns:
    the expression contained in the return clause

### hasVariableBinding

    public boolean hasVariableBinding(Binding binding)

  Determine whether a given variable binding belongs to this FLWOR expression

  Overrides:
    `hasVariableBinding` in class `Expression`
  Parameters:
    `binding` - the binding being sought
  Returns:
    true if this binding belongs to one of the clauses of this FLWOR expression

### simplify

    public Expression simplify(ExpressionVisitor visitor)
                        throws XPathException

  Simplify an expression. This performs any static optimization (by rewriting the expression as a different expression). The default implementation does nothing.

  Overrides:
    `simplify` in class `Expression`
  Parameters:
    `visitor` - an expression visitor
  Returns:
    the simplified expression
  Throws:
    `XPathException` - if an error is discovered during expression rewriting

### typeCheck

    public Expression typeCheck(ExpressionVisitor visitor,
                                ExpressionVisitor.ContextItemType contextItemType)
                         throws XPathException

  Perform type checking of an expression and its subexpressions. This is the second phase of static optimization.

  This checks statically that the operands of the expression have the correct type; if necessary it generates code to do run-time type checking or type conversion. A static type error is reported only if execution cannot possibly succeed, that is, if a run-time type error is inevitable. The call may return a modified form of the expression.

  This method is called after all references to functions and variables have been resolved to the declaration of the function or variable. However, the types of such functions and variables may not be accurately known if they have not been explicitly declared.

  If the implementation returns a value other than "this", then it is required to ensure that the location information in the returned expression have been set up correctly. It should not rely on the caller to do this, although for historical reasons many callers do so.

  Overrides:
    `typeCheck` in class `Expression`
  Parameters:
    `visitor` - an expression visitor
    `contextItemType` - the static type of "." at the point where this expression is invoked. The parameter is set to null if it is known statically that the context item will be undefined. If the type of the context item is not known statically, the argument is set to `Type.ITEM_TYPE`
  Returns:
    the original expression, rewritten to perform necessary run-time type checks, and to perform other type-related optimizations
  Throws:
    `XPathException` - if an error is discovered during this phase (typically a type error)

### getItemType

    public ItemType getItemType(TypeHierarchy th)

  Determine the data type of the items returned by the expression.

  Specified by:
    `getItemType` in class `Expression`
  Parameters:
    `th` - the type hierarchy cache
  Returns:
    a value such as Type.STRING, Type.BOOLEAN, Type.NUMBER, Type.NODE, or Type.ITEM (meaning not known at compile time)

### computeCardinality

    protected int computeCardinality()

  Compute the static cardinality of this expression

  Specified by:
    `computeCardinality` in class `Expression`
  Returns:
    the computed cardinality, as one of the values `StaticProperty.ALLOWS_ZERO_OR_ONE`, `StaticProperty.EXACTLY_ONE`, `StaticProperty.ALLOWS_ONE_OR_MORE`, `StaticProperty.ALLOWS_ZERO_OR_MORE`

### iterateSubExpressions

    public Iterator<Expression> iterateSubExpressions()

  Get the immediate sub-expressions of this expression.

  Overrides:
    `iterateSubExpressions` in class `Expression`
  Returns:
    an iterator containing the sub-expressions of this expression

### checkForUpdatingSubexpressions

    public void checkForUpdatingSubexpressions()
                                        throws XPathException

  Check to ensure that this expression does not contain any inappropriate updating subexpressions. This check is overridden for those expressions that permit updating subexpressions.

  Overrides:
    `checkForUpdatingSubexpressions` in class `Expression`
  Throws:
    `XPathException` - if the expression has a non-permitted updateing subexpression

### isUpdatingExpression

    public boolean isUpdatingExpression()

  Determine whether this is an updating expression as defined in the XQuery update specification

  Overrides:
    `isUpdatingExpression` in class `Expression`
  Returns:
    true if this is an updating expression

### replaceSubExpression

    public boolean replaceSubExpression(Expression original,
                                        Expression replacement)

  Replace one subexpression by a replacement subexpression

  Overrides:
    `replaceSubExpression` in class `Expression`
  Parameters:
    `original` - the original subexpression
    `replacement` - the replacement subexpression
  Returns:
    true if the original subexpression is found

### replaceVariable

    public void replaceVariable(Optimizer opt,
                                Expression seq)
                         throws XPathException

  Replace all references to the variable bound by this let expression, that occur within the action expression, with the given expression

  Parameters:
    `opt` - The optimizer
    `seq` - the expression
  Throws:
    `XPathException` - if an error occurs

### explain

    public void explain(ExpressionPresenter out)

  Diagnostic print of expression structure. The abstract expression tree is written to the supplied output destination.

  Specified by:
    `explain` in class `Expression`
  Parameters:
    `out` - the expression presenter used to display the structure

### copy

    public Expression copy()

  Copy an expression. This makes a deep copy.

  Specified by:
    `copy` in class `Expression`
  Returns:
    the copy of the original expression

### promote

    public Expression promote(PromotionOffer offer,
                              Expression parent)
                       throws XPathException

  Promote this expression if possible

  Overrides:
    `promote` in class `Expression`
  Parameters:
    `offer` - details of the offer, for example the offer to move expressions that don't depend on the context to an outer level in the containing expression
    `parent` - the containing expression in the expression tree
  Returns:
    if the offer is not accepted, return this expression unchanged. Otherwise return the result of rewriting the expression to promote this subexpression
  Throws:
    `XPathException` - if any error is detected

### getEvaluationMethod

    public int getEvaluationMethod()

  Overrides:
    `getEvaluationMethod` in class `Expression`

### optimize

    public Expression optimize(ExpressionVisitor visitor,
                               ExpressionVisitor.ContextItemType contextItemType)
                        throws XPathException

  Description copied from class: `Expression`
  Perform optimisation of an expression and its subexpressions. This is the third and final phase of static optimization.

  This method is called after all references to functions and variables have been resolved to the declaration of the function or variable, and after all type checking has been done.

  Overrides:
    `optimize` in class `Expression`
  Parameters:
    `visitor` - an expression visitor
    `contextItemType` - the static type of "." at the point where this expression is invoked. The parameter is set to null if it is known statically that the context item will be undefined. If the type of the context item is not known statically, the argument is set to `Type.ITEM_TYPE`
  Returns:
    the original expression, rewritten if appropriate to optimize execution
  Throws:
    `XPathException` - if an error is discovered during this phase (typically a type error)

### iterate

    public SequenceIterator<? extends Item> iterate(XPathContext context)
                                             throws XPathException

  Return an Iterator to iterate over the values of a sequence. The value of every expression can be regarded as a sequence, so this method is supported for all expressions. This default implementation handles iteration for expressions that return singleton values: for non-singleton expressions, the subclass must provide its own implementation.

  Overrides:
    `iterate` in class `Expression`
  Parameters:
    `context` - supplies the context for evaluation
  Returns:
    a SequenceIterator that can be used to iterate over the result of the expression
  Throws:
    `XPathException` - if any dynamic error occurs evaluating the expression

### process

    public void process(XPathContext context)
                 throws XPathException

  Process the instruction, without returning any tail calls

  Overrides:
    `process` in class `Expression`
  Parameters:
    `context` - The dynamic context, giving access to the current node, the current variables, etc.
  Throws:
    `XPathException` - if a dynamic error occurs

### evaluatePendingUpdates

    public void evaluatePendingUpdates(XPathContext context,
                                       PendingUpdateList pul)
                                throws XPathException

  Evaluate an updating expression, adding the results to a Pending Update List. The default implementation of this method, which is used for non-updating expressions, throws an UnsupportedOperationException

  Overrides:
    `evaluatePendingUpdates` in class `Expression`
  Parameters:
    `context` - the XPath dynamic evaluation context
    `pul` - the pending update list to which the results should be written
  Throws:
    `XPathException` - if evaluation fails
    `UnsupportedOperationException` - if the expression is not an updating expression

### toString

    public String toString()

  Display the expression as a string

  Overrides:
    `toString` in class `Expression`
  Returns:
    a representation of the expression as a string

### hasLoopingVariableReference

    public boolean hasLoopingVariableReference(Binding binding,
                                               Expression reference)

Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright (c) 2004-2011 Saxonica Limited. All rights reserved.