com.saxonica.ee.update

Class RenameExpression

java.lang.Object

net.sf.saxon.expr.Expression

com.saxonica.ee.update.BasicUpdatingExpression

com.saxonica.ee.update.RenameExpression

All Implemented Interfaces:

SourceLocator, IdentityComparable, InstructionInfo

public class RenameExpression
extends BasicUpdatingExpression

A rename expression in XQuery Update

Field Summary

Fields inherited from class net.sf.saxon.expr.Expression

EFFECTIVE_BOOLEAN_VALUE, EVALUATE_METHOD, ITEM_FEED_METHOD, ITERATE_METHOD, locationId, MAX_SEQUENCE_LENGTH, MAX_STRING_LENGTH, PROCESS_METHOD, staticProperties, UNBOUNDED_LOWER, UNBOUNDED_UPPER, WATCH_METHOD

Constructor Summary

Constructors

Constructor and Description
RenameExpression(Expression target, Expression name, NamespaceResolver nsContext, String defaultNamespace) Create a RenameExpression

Method Summary

Methods

Modifier and Type	Method and Description
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.
ExpressionCompiler	getExpressionCompiler() Return the compiler of the Rename expression
Iterable<Operand>	operands() Get the immediate sub-expressions of this expression, with information about the relationship of each expression to its parent expression.
Expression	optimize(ExpressionVisitor visitor, ContextItemStaticInfo contextItemType) Perform optimisation of an expression and its subexpressions.
Expression	promote(PromotionOffer offer, Expression parent) Promote this expression if possible
boolean	replaceOperand(Expression original, Expression replacement) Replace one subexpression by a replacement subexpression
Expression	typeCheck(ExpressionVisitor visitor, ContextItemStaticInfo contextInfo) Perform type checking of an expression and its subexpressions.

Methods inherited from class com.saxonica.ee.update.BasicUpdatingExpression

computeCardinality, evaluateItem, getItemType, isUpdatingExpression, iterate, process

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

addToPathMap, adoptChildExpression, checkForUpdatingSubexpressions, checkPermittedContents, clearStreamabilityData, computeDependencies, computeSpecialProperties, computeStaticProperties, doPromotion, dynamicError, effectiveBooleanValue, evaluateAsString, explain, getCardinality, getColumnNumber, getConfiguration, getConstructType, getContainer, getDependencies, getEvaluationMethod, getExpressionName, getHostLanguage, getImplementationMethod, getIntegerBounds, getIntrinsicDependencies, getLineNumber, getLocationId, getObjectName, getPosture, getProperties, getProperty, getPublicId, getSlotsUsed, getSpecialProperties, getStreamability, getStreamingAdjunct, getSweep, getSystemId, hasVariableBinding, identityHashCode, implementsStaticTypeCheck, isIdentical, isSubtreeExpression, isVacuousExpression, iterateEvents, makeStreamingAdjunct, markTailFunctionCalls, operandList, resetLocalStaticProperties, setContainer, setEvaluationMethod, setFiltered, setFlattened, setLocationId, setPostureAndSweep, simplify, staticTypeCheck, suppressValidation, toPattern, toShortString, toStreamingPattern, toString, typeError, unordered

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Constructor Detail

RenameExpression

public RenameExpression(Expression target,
                Expression name,
                NamespaceResolver nsContext,
                String defaultNamespace)

Create a RenameExpression

Parameters:

target - expression that computes the nodes to be renamed

name - expression that computes the new name

nsContext - the static namespace context (needed at runtime)

defaultNamespace - the default namespace for elements and types

Method Detail

typeCheck

public Expression typeCheck(ExpressionVisitor visitor,
                   ContextItemStaticInfo contextInfo)
                     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 parent pointer and 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

contextInfo -

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)

optimize

public Expression optimize(ExpressionVisitor visitor,
                  ContextItemStaticInfo contextItemType)
                    throws XPathException

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)

operands

public Iterable<Operand> operands()

Description copied from class: Expression

Get the immediate sub-expressions of this expression, with information about the relationship of each expression to its parent expression. Default implementation works off the results of iterateSubExpressions()

If the expression is a Callable, then it is required that the order of the operands returned by this function is the same as the order of arguments supplied to the corresponding call() method.

Overrides:

operands in class Expression

Returns:

an iterator containing the sub-expressions of this 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

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

replaceOperand

public boolean replaceOperand(Expression original,
                     Expression replacement)

Replace one subexpression by a replacement subexpression

Overrides:

replaceOperand in class Expression

Parameters:

original - the original subexpression

replacement - the replacement subexpression

Returns:

true if the original subexpression is found

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

evaluatePendingUpdates

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

Evaluate an updating expression, adding the results to a Pending Update List.

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

getExpressionCompiler

public ExpressionCompiler getExpressionCompiler()

Return the compiler of the Rename expression

Overrides:

getExpressionCompiler in class Expression

Returns:

the relevant ExpressionCompiler