net.sf.saxon.expr

Class FilterExpression

java.lang.Object

net.sf.saxon.expr.Expression

net.sf.saxon.expr.BinaryExpression

net.sf.saxon.expr.FilterExpression

All Implemented Interfaces:

ContextOriginator, ContextSwitchingExpression, IdentityComparable

public final class FilterExpression
extends BinaryExpression
implements ContextSwitchingExpression

A FilterExpression contains a base expression and a filter predicate, which may be an integer expression (positional filter), or a boolean expression (qualifier)

Field Summary

Fields

Modifier and Type	Field and Description
static OperandRole	FILTER_PREDICATE
static int	FILTERED

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

operator

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

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

Constructor Summary

Constructors

Constructor and Description
FilterExpression(Expression base, Expression filter) Constructor

Method Summary

Methods

Modifier and Type	Method and Description
PathMap.PathMapNodeSet	addToPathMap(PathMap pathMap, PathMap.PathMapNodeSet pathMapNodeSet) Add a representation of this expression to a PathMap.
int	computeCardinality() Get the static cardinality of this expression
int	computeSpecialProperties() Get the static properties of this expression (other than its type).
Expression	copy() Copy an expression.
boolean	equals(Object other) Is this expression the same as another expression?
void	export(ExpressionPresenter out) Diagnostic print of expression structure.
Expression	getActionExpression() Get the subexpression that is evaluated in the new context
Expression	getBase()
int	getCost() Return the estimated cost of evaluating an expression.
ExpressionCompiler	getExpressionCompiler() Return the compiler of the Filter expression
String	getExpressionName() Get a name identifying the kind of expression, in terms meaningful to a user.
Expression	getFilter() Get the filter expression
int	getImplementationMethod() An implementation of Expression must provide at least one of the methods evaluateItem(), iterate(), or process().
IntegerValue[]	getIntegerBounds() For an expression that returns an integer or a sequence of integers, get a lower and upper bound on the values of the integers that may be returned, from static analysis.
ItemType	getItemType() Get the data type of the items returned
protected OperandRole	getOperandRole(int arg) Get the operand role
Expression	getSelectExpression() Get the base expression
FilterExpressionAdjunct	getStreamingAdjunct() Get a class that supports streamed evaluation of this expression
int	hashCode() get HashCode for comparing two expressions
boolean	isFilterIsPositional()
boolean	isIndependentFilter() Determine whether the filter is independent of the context item and position
boolean	isPositional(TypeHierarchy th) Determine if the filter is positional
static boolean	isPositionalFilter(Expression exp, TypeHierarchy th) Determine whether an expression, when used as a filter, is potentially positional; that is, where it either contains a call on position() or last(), or where it is capable of returning a numeric result.
boolean	isSimpleBooleanFilter() Test if the filter always returns a singleton boolean.
SequenceIterator	iterate(XPathContext context) Iterate over the results, returning them in the correct order
Expression	optimize(ExpressionVisitor visitor, ContextItemStaticInfo contextItemType) Perform optimisation of an expression and its subexpressions.
Expression	promote(PromotionOffer offer) Promote this expression if possible
void	setBase(Expression base)
void	setFilter(Expression filter)
void	setFlags(String flags)
Expression	simplify() Simplify an expression
Pattern	toPattern(Configuration config, boolean is30) Convert this expression to an equivalent XSLT pattern
String	toShortString() Produce a short string identifying the expression for use in error messages
String	toString() The toString() method for an expression attempts to give a representation of the expression in an XPath-like form, but there is no guarantee that the syntax will actually be true XPath.
Expression	typeCheck(ExpressionVisitor visitor, ContextItemStaticInfo contextInfo) Type-check the expression param visitor the expression visitor
Expression	unordered(boolean retainAllNodes, boolean forStreaming) Replace this expression by a simpler expression that delivers the results without regard to order.

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

displayOperator, explainExtraAttributes, getLhs, getLhsExpression, getOperator, getRhs, getRhsExpression, isAssociative, isCommutative, isInverse, operands, setFlattened, setLhsExpression, setRhsExpression, tag

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

adoptChildExpression, checkedOperands, checkForUpdatingSubexpressions, checkPermittedContents, clearStreamabilityData, computeDependencies, computeStaticProperties, doPromotion, dynamicError, effectiveBooleanValue, evaluateAsString, evaluateItem, evaluatePendingUpdates, explain, getCardinality, getConfiguration, getConstructType, getDependencies, getEvaluationMethod, getHostLanguage, getIntrinsicDependencies, getLocation, getNetCost, getObjectName, getPackageData, getParentExpression, getPosture, getPostureAndSweepIfKnown, getProperties, getProperty, getRetainedStaticContext, getSlotsUsed, getSpecialProperties, getStaticBaseURI, getStaticBaseURIString, getStreamability, getSweep, getSystemId, hasVariableBinding, identityHashCode, implementsStaticTypeCheck, isCallOn, isCallOnSystemFunction, isIdentical, isSubtreeExpression, isUpdatingExpression, isVacuousExpression, iterateEvents, makeStreamingAdjunct, markTailFunctionCalls, operandList, operandSparseList, optimizeChildren, optimizeForType, process, promoteChildren, resetLocalStaticProperties, restoreParentPointers, setEvaluationMethod, setFiltered, setLocation, setParentExpression, setPostureAndSweep, setRetainedStaticContext, setRetainedStaticContextLocally, setStaticProperty, simplifyChildren, staticTypeCheck, suppressValidation, toStreamingPattern, typeCheckChildren, typeError

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Field Detail

FILTERED

public static final int FILTERED

See Also:

Constant Field Values

FILTER_PREDICATE

public static final OperandRole FILTER_PREDICATE

Constructor Detail

FilterExpression

public FilterExpression(Expression base,
                Expression filter)

Constructor

Parameters:

base - The base expression to be filtered.

filter - An expression defining the filter predicate

Method Detail

getOperandRole

protected OperandRole getOperandRole(int arg)

Description copied from class: BinaryExpression

Get the operand role

Overrides:

getOperandRole in class BinaryExpression

Parameters:

arg - which argument: 0 for the lhs, 1 for the rhs

Returns:

the operand role

getBase

public Expression getBase()

setBase

public void setBase(Expression base)

getFilter

public Expression getFilter()

Get the filter expression

Returns:

the expression acting as the filter predicate

setFilter

public void setFilter(Expression filter)

getExpressionName

public String getExpressionName()

Get a name identifying the kind of expression, in terms meaningful to a user.

Overrides:

getExpressionName in class Expression

Returns:

a name identifying the kind of expression, in terms meaningful to a user. The name will always be in the form of a lexical XML QName, and should match the name used in explain() output displaying the expression.

getItemType

public ItemType getItemType()

Get the data type of the items returned

Specified by:

getItemType in class Expression

Returns:

an integer representing the data type

getSelectExpression

public Expression getSelectExpression()

Get the base expression

Specified by:

getSelectExpression in interface ContextSwitchingExpression

Returns:

the base expression being filtered

isFilterIsPositional

public boolean isFilterIsPositional()

Returns:

the boolean of filter is positional

See Also:

FilterExpressionCompiler

getActionExpression

public Expression getActionExpression()

Get the subexpression that is evaluated in the new context

Specified by:

getActionExpression in interface ContextSwitchingExpression

Returns:

the subexpression evaluated in the context set by the controlling expression

isPositional

public boolean isPositional(TypeHierarchy th)

Determine if the filter is positional

Parameters:

th - the Type Hierarchy (for cached access to type information)

Returns:

true if the value of the filter depends on the position of the item against which it is evaluated

isSimpleBooleanFilter

public boolean isSimpleBooleanFilter()

Test if the filter always returns a singleton boolean.

This information is available only after typeCheck() has been called.

Returns:

true if the filter is a simple boolean expression

isIndependentFilter

public boolean isIndependentFilter()

Determine whether the filter is independent of the context item and position

This information is available only after typeCheck() has been called.

Returns:

true if the filter is a numeric value that does not depend on the context item or position

simplify

public Expression simplify()
                    throws XPathException

Simplify an expression

Overrides:

simplify in class Expression

Returns:

the simplified expression (or the original if unchanged, or if modified in-situ)

Throws:

XPathException - if any failure occurs

typeCheck

public Expression typeCheck(ExpressionVisitor visitor,
                   ContextItemStaticInfo contextInfo)
                     throws XPathException

Type-check the expression

param visitor the expression visitor

Overrides:

typeCheck in class BinaryExpression

Parameters:

contextInfo - return the expression after type-checking (potentially modified to add run-time checks and/or conversions)

visitor - an expression visitor

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 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 BinaryExpression

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)

getCost

public int getCost()

Return the estimated cost of evaluating an expression. This is a very crude measure based on the syntactic form of the expression (we have no knowledge of data values). We take the cost of evaluating a simple scalar comparison or arithmetic expression as 1 (one), and we assume that a sequence has length 5. The resulting estimates may be used, for example, to reorder the predicates in a filter expression so cheaper predicates are evaluated first.

Overrides:

getCost in class Expression

Returns:

an estimate of the gross cost of evaluating the expression, including the cost of evaluating its operands.

getImplementationMethod

public int getImplementationMethod()

An implementation of Expression must provide at least one of the methods evaluateItem(), iterate(), or process(). This method indicates which of these methods is provided directly. The other methods will always be available indirectly, using an implementation that relies on one of the other methods.

Overrides:

getImplementationMethod in class BinaryExpression

Returns:

the implementation method, for example Expression.ITERATE_METHOD or Expression.EVALUATE_METHOD or Expression.PROCESS_METHOD

getIntegerBounds

public IntegerValue[] getIntegerBounds()

For an expression that returns an integer or a sequence of integers, get a lower and upper bound on the values of the integers that may be returned, from static analysis. The default implementation returns null, meaning "unknown" or "not applicable". Other implementations return an array of two IntegerValue objects, representing the lower and upper bounds respectively. The values UNBOUNDED_LOWER and UNBOUNDED_UPPER are used by convention to indicate that the value may be arbitrarily large. The values MAX_STRING_LENGTH and MAX_SEQUENCE_LENGTH are used to indicate values limited by the size of a string or the size of a sequence.

Overrides:

getIntegerBounds in class Expression

Returns:

the lower and upper bounds of integer values in the result, or null to indicate unknown or not applicable.

addToPathMap

public PathMap.PathMapNodeSet addToPathMap(PathMap pathMap,
                                  PathMap.PathMapNodeSet pathMapNodeSet)

Add a representation of this expression to a PathMap. The PathMap captures a map of the nodes visited by an expression in a source tree.

Overrides:

addToPathMap in class Expression

Parameters:

pathMap - the PathMap to which the expression should be added

pathMapNodeSet - the PathMapNodeSet to which the paths embodied in this expression should be added

Returns:

the pathMapNode representing the focus established by this expression, in the case where this expression is the first operand of a path expression or filter expression

promote

public Expression promote(PromotionOffer offer)
                   throws XPathException

Promote this expression if possible

Overrides:

promote in class Expression

Parameters:

offer - details of the promotion that is possible

Returns:

the promoted expression (or the original expression, unchanged)

Throws:

XPathException - if any error is detected

unordered

public Expression unordered(boolean retainAllNodes,
                   boolean forStreaming)
                     throws XPathException

Replace this expression by a simpler expression that delivers the results without regard to order.

Overrides:

unordered in class Expression

Parameters:

retainAllNodes - set to true if the result must contain exactly the same nodes as the original; set to false if the result can eliminate (or introduce) duplicates.

forStreaming - set to true if optimizing for streaming

Returns:

an expression that delivers the same nodes in a more convenient order

Throws:

XPathException - if the rewrite fails

isPositionalFilter

public static boolean isPositionalFilter(Expression exp,
                         TypeHierarchy th)

Determine whether an expression, when used as a filter, is potentially positional; that is, where it either contains a call on position() or last(), or where it is capable of returning a numeric result.

Parameters:

exp - the expression to be examined

th - the type hierarchy cache

Returns:

true if the expression depends on position() or last() explicitly or implicitly

computeCardinality

public int computeCardinality()

Get the static cardinality of this expression

Overrides:

computeCardinality in class BinaryExpression

Returns:

the cardinality. The method attempts to determine the case where the filter predicate is guaranteed to select at most one item from the sequence being filtered

computeSpecialProperties

public int computeSpecialProperties()

Get the static properties of this expression (other than its type). The result is bit-significant. These properties are used for optimizations. In general, if property bit is set, it is true, but if it is unset, the value is unknown.

Overrides:

computeSpecialProperties in class BinaryExpression

Returns:

the static properties of the expression, as a bit-significant value

equals

public boolean equals(Object other)

Is this expression the same as another expression?

Overrides:

equals in class BinaryExpression

Parameters:

other - the expression to be compared with this one

Returns:

true if the two expressions are statically equivalent

hashCode

public int hashCode()

get HashCode for comparing two expressions

Overrides:

hashCode in class BinaryExpression

Returns:

the hash code

toPattern

public Pattern toPattern(Configuration config,
                boolean is30)
                  throws XPathException

Convert this expression to an equivalent XSLT pattern

Overrides:

toPattern in class Expression

Parameters:

config - the Saxon configuration

is30 - true if this is XSLT 3.0

Returns:

the equivalent pattern

Throws:

XPathException - if conversion is not possible

iterate

public SequenceIterator iterate(XPathContext context)
                         throws XPathException

Iterate over the results, returning them in the correct order

Overrides:

iterate in class Expression

Parameters:

context - the dynamic context for the evaluation

Returns:

an iterator over the expression results

Throws:

XPathException - if any dynamic error occurs

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

getExpressionCompiler

public ExpressionCompiler getExpressionCompiler()

Return the compiler of the Filter expression

Overrides:

getExpressionCompiler in class Expression

Returns:

the relevant ExpressionCompiler

getStreamingAdjunct

public FilterExpressionAdjunct getStreamingAdjunct()

Get a class that supports streamed evaluation of this expression

Overrides:

getStreamingAdjunct in class Expression

Returns:

the relevant StreamingAdjunct, or null if none is available

toString

public String toString()

The toString() method for an expression attempts to give a representation of the expression in an XPath-like form, but there is no guarantee that the syntax will actually be true XPath. In the case of XSLT instructions, the toString() method gives an abstracted view of the syntax

Overrides:

toString in class BinaryExpression

Returns:

the expression as a string in XPath 3.0 syntax

toShortString

public String toShortString()

Description copied from class: Expression

Produce a short string identifying the expression for use in error messages

Overrides:

toShortString in class BinaryExpression

Returns:

a short string, sufficient to identify the expression

export

public void export(ExpressionPresenter out)

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

Overrides:

export in class BinaryExpression

Parameters:

out - the ExpressionPresenter to be used

setFlags

public void setFlags(String flags)