com.espertech.esper.epl.expression.core

Class ExprNodeUtilityCore

java.lang.Object

com.espertech.esper.epl.expression.core.ExprNodeUtilityCore

public class ExprNodeUtilityCore
extends java.lang.Object

Field Summary

Fields

Modifier and Type	Field and Description
static ExprNode[]	EMPTY_EXPR_ARRAY
static ExprForge[]	EMPTY_FORGE_ARRAY

Constructor Summary

Constructors

Constructor and Description
ExprNodeUtilityCore()

Method Summary

Modifier and Type	Method and Description
static void	acceptParams(ExprNodeVisitor visitor, java.util.List<ExprNode> params)
static void	acceptParams(ExprNodeVisitorWithParent visitor, java.util.List<ExprNode> params)
static void	acceptParams(ExprNodeVisitorWithParent visitor, java.util.List<ExprNode> params, ExprNode parent)
static ExprNode[]	addExpression(ExprNode[] expressions, ExprNode expression)
static boolean	applyFilterExpression(ExprEvaluator filter, EventBean[] eventsPerStream, ExprEvaluatorContext exprEvaluatorContext) Apply a filter expression returning a pass indicator.
static EventBean[]	applyFilterExpression(ExprEvaluator filter, EventBean streamZeroEvent, EventBean[] streamOneEvents, ExprEvaluatorContext exprEvaluatorContext) Apply a filter expression.
static void	applyFilterExpressionIterable(java.util.Iterator<EventBean> iterator, ExprEvaluator filterExpression, ExprEvaluatorContext exprEvaluatorContext, java.util.Collection<EventBean> eventsInWindow)
static void	applyFilterExpressionsIterable(java.lang.Iterable<EventBean> iterable, java.util.List<ExprNode> filterExpressions, ExprEvaluatorContext exprEvaluatorContext, java.util.Collection<EventBean> eventsInWindow)
static boolean	deepEquals(ExprNode[] one, ExprNode[] two, boolean ignoreStreamPrefix) Compares two expression nodes via deep comparison, considering all child nodes of either side.
static boolean	deepEquals(ExprNode nodeOne, ExprNode nodeTwo, boolean ignoreStreamPrefix) Compare two expression nodes and their children in exact child-node sequence, returning true if the 2 expression nodes trees are equals, or false if they are not equals.
static boolean	deepEquals(java.util.List<ExprNode> one, java.util.List<ExprNode> two)
static boolean	deepEqualsIgnoreDupAndOrder(ExprNode[] setOne, ExprNode[] setTwo)
static boolean	deepEqualsIsSubset(ExprNode[] subset, ExprNode[] superset)
static boolean	deepEqualsNullChecked(ExprNode nodeOne, ExprNode nodeTwo, boolean ignoreStreamPrefix)
static java.lang.Object[]	evaluateExpressions(ExprEvaluator[] parameters, ExprEvaluatorContext exprEvaluatorContext)
static java.lang.Object	evaluateValidationTimeNoStreams(ExprEvaluator evaluator, ExprEvaluatorContext context, java.lang.String expressionName)
static java.util.List<Pair<ExprNode,ExprNode>>	findExpression(ExprNode selectExpression, ExprNode searchExpression)
static java.util.Comparator<java.lang.Object>	getComparatorHashableMultiKeys(ExprNode[] sortCriteria, boolean isSortUsingCollator, boolean[] isDescendingValues)
static ExprEvaluator[]	getEvaluatorsNoCompile(ExprForge[] forges)
static ExprEvaluator[]	getEvaluatorsNoCompile(ExprNode[] exprNodes)
static ExprEvaluator[]	getEvaluatorsNoCompile(java.util.List<ExprNode> childNodes)
static ExprIdentNode	getExprIdentNode(EventType[] typesPerStream, int streamId, java.lang.String property)
static java.lang.Class[]	getExprResultTypes(ExprForge[] nodes)
static java.lang.Class[]	getExprResultTypes(ExprNode[] nodes)
static java.lang.Class[]	getExprResultTypes(java.util.List<ExprNode> expressions)
static ExprForge[]	getForges(ExprNode[] exprNodes)
static java.lang.String[]	getIdentResolvedPropertyNames(ExprNode[] nodes)
static java.util.Set<java.lang.String>	getPropertyNamesIfAllProps(ExprNode[] expressions)
static boolean	isConstantValueExpr(ExprNode exprNode)
static java.lang.String	printEvaluators(ExprEvaluator[] evaluators)
static void	replaceChildNode(ExprNode parentNode, ExprNode nodeToReplace, ExprNode newNode)
static ExprNode[]	toArray(java.util.Collection<ExprNode> expressions)
static void	toExpressionString(ExprNode node, java.io.StringWriter buffer)
static void	toExpressionStringIncludeParen(java.util.List<ExprNode> parameters, java.io.StringWriter buffer)
static java.lang.String[]	toExpressionStringMinPrecedenceAsArray(ExprNode[] nodes)
static java.lang.String	toExpressionStringMinPrecedenceAsList(ExprNode[] nodes)
static void	toExpressionStringMinPrecedenceAsList(ExprNode[] nodes, java.io.StringWriter writer)
static java.lang.String	toExpressionStringMinPrecedenceSafe(ExprNode node)
static void	toExpressionStringParameterList(ExprNode[] childNodes, java.io.StringWriter buffer)
static void	toExpressionStringParameterList(java.util.List<ExprNode> parameters, java.io.StringWriter buffer)
static void	toExpressionStringParams(java.io.StringWriter writer, ExprNode[] params)
static java.lang.String[]	toExpressionStringsMinPrecedence(ExprNode[] expressions)
static void	toExpressionStringWFunctionName(java.lang.String functionName, ExprNode[] childNodes, java.io.StringWriter writer)

Methods inherited from class java.lang.Object

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

Field Detail

EMPTY_EXPR_ARRAY

public static final ExprNode[] EMPTY_EXPR_ARRAY

EMPTY_FORGE_ARRAY

public static final ExprForge[] EMPTY_FORGE_ARRAY

Constructor Detail

ExprNodeUtilityCore

public ExprNodeUtilityCore()

Method Detail

getComparatorHashableMultiKeys

public static java.util.Comparator<java.lang.Object> getComparatorHashableMultiKeys(ExprNode[] sortCriteria,
                                                                                    boolean isSortUsingCollator,
                                                                                    boolean[] isDescendingValues)

evaluateValidationTimeNoStreams

public static java.lang.Object evaluateValidationTimeNoStreams(ExprEvaluator evaluator,
                                                               ExprEvaluatorContext context,
                                                               java.lang.String expressionName)
                                                        throws ExprValidationException

Throws:

ExprValidationException

deepEqualsIsSubset

public static boolean deepEqualsIsSubset(ExprNode[] subset,
                                         ExprNode[] superset)

deepEqualsIgnoreDupAndOrder

public static boolean deepEqualsIgnoreDupAndOrder(ExprNode[] setOne,
                                                  ExprNode[] setTwo)

toExpressionStringMinPrecedenceSafe

public static java.lang.String toExpressionStringMinPrecedenceSafe(ExprNode node)

toExpressionStringMinPrecedenceAsArray

public static java.lang.String[] toExpressionStringMinPrecedenceAsArray(ExprNode[] nodes)

toExpressionStringMinPrecedenceAsList

public static java.lang.String toExpressionStringMinPrecedenceAsList(ExprNode[] nodes)

toExpressionStringMinPrecedenceAsList

public static void toExpressionStringMinPrecedenceAsList(ExprNode[] nodes,
                                                         java.io.StringWriter writer)

applyFilterExpressionsIterable

public static void applyFilterExpressionsIterable(java.lang.Iterable<EventBean> iterable,
                                                  java.util.List<ExprNode> filterExpressions,
                                                  ExprEvaluatorContext exprEvaluatorContext,
                                                  java.util.Collection<EventBean> eventsInWindow)

applyFilterExpressionIterable

public static void applyFilterExpressionIterable(java.util.Iterator<EventBean> iterator,
                                                 ExprEvaluator filterExpression,
                                                 ExprEvaluatorContext exprEvaluatorContext,
                                                 java.util.Collection<EventBean> eventsInWindow)

isConstantValueExpr

public static boolean isConstantValueExpr(ExprNode exprNode)

getPropertyNamesIfAllProps

public static java.util.Set<java.lang.String> getPropertyNamesIfAllProps(ExprNode[] expressions)

toExpressionStringsMinPrecedence

public static java.lang.String[] toExpressionStringsMinPrecedence(ExprNode[] expressions)

findExpression

public static java.util.List<Pair<ExprNode,ExprNode>> findExpression(ExprNode selectExpression,
                                                                     ExprNode searchExpression)

toExpressionStringParameterList

public static void toExpressionStringParameterList(ExprNode[] childNodes,
                                                   java.io.StringWriter buffer)

toExpressionStringWFunctionName

public static void toExpressionStringWFunctionName(java.lang.String functionName,
                                                   ExprNode[] childNodes,
                                                   java.io.StringWriter writer)

getIdentResolvedPropertyNames

public static java.lang.String[] getIdentResolvedPropertyNames(ExprNode[] nodes)

getExprResultTypes

public static java.lang.Class[] getExprResultTypes(ExprNode[] nodes)

getExprResultTypes

public static java.lang.Class[] getExprResultTypes(ExprForge[] nodes)

addExpression

public static ExprNode[] addExpression(ExprNode[] expressions,
                                       ExprNode expression)

applyFilterExpression

public static EventBean[] applyFilterExpression(ExprEvaluator filter,
                                                EventBean streamZeroEvent,
                                                EventBean[] streamOneEvents,
                                                ExprEvaluatorContext exprEvaluatorContext)

Apply a filter expression.

Parameters:

filter - expression

streamZeroEvent - the event that represents stream zero

streamOneEvents - all events thate are stream one events

exprEvaluatorContext - context for expression evaluation

Returns:

filtered stream one events

applyFilterExpression

public static boolean applyFilterExpression(ExprEvaluator filter,
                                            EventBean[] eventsPerStream,
                                            ExprEvaluatorContext exprEvaluatorContext)

Apply a filter expression returning a pass indicator.

Parameters:

filter - to apply

eventsPerStream - events per stream

exprEvaluatorContext - context for expression evaluation

Returns:

pass indicator

deepEquals

public static boolean deepEquals(ExprNode nodeOne,
                                 ExprNode nodeTwo,
                                 boolean ignoreStreamPrefix)

Compare two expression nodes and their children in exact child-node sequence, returning true if the 2 expression nodes trees are equals, or false if they are not equals.

Recursive call since it uses this method to compare child nodes in the same exact sequence. Nodes are compared using the equalsNode method.

Parameters:

nodeOne - - first expression top node of the tree to compare

nodeTwo - - second expression top node of the tree to compare

ignoreStreamPrefix - when the equals-comparison can ignore prefix of event properties

Returns:

false if this or all child nodes are not equal, true if equal

deepEqualsNullChecked

public static boolean deepEqualsNullChecked(ExprNode nodeOne,
                                            ExprNode nodeTwo,
                                            boolean ignoreStreamPrefix)

deepEquals

public static boolean deepEquals(ExprNode[] one,
                                 ExprNode[] two,
                                 boolean ignoreStreamPrefix)

Compares two expression nodes via deep comparison, considering all child nodes of either side.

Parameters:

one - array of expressions

two - array of expressions

ignoreStreamPrefix - indicator whether we ignore stream prefixes and instead use resolved property name

Returns:

true if the expressions are equal, false if not

deepEquals

public static boolean deepEquals(java.util.List<ExprNode> one,
                                 java.util.List<ExprNode> two)

evaluateExpressions

public static java.lang.Object[] evaluateExpressions(ExprEvaluator[] parameters,
                                                     ExprEvaluatorContext exprEvaluatorContext)

toArray

public static ExprNode[] toArray(java.util.Collection<ExprNode> expressions)

getEvaluatorsNoCompile

public static ExprEvaluator[] getEvaluatorsNoCompile(ExprNode[] exprNodes)

getForges

public static ExprForge[] getForges(ExprNode[] exprNodes)

getEvaluatorsNoCompile

public static ExprEvaluator[] getEvaluatorsNoCompile(ExprForge[] forges)

getEvaluatorsNoCompile

public static ExprEvaluator[] getEvaluatorsNoCompile(java.util.List<ExprNode> childNodes)

toExpressionStringParams

public static void toExpressionStringParams(java.io.StringWriter writer,
                                            ExprNode[] params)

getExprResultTypes

public static java.lang.Class[] getExprResultTypes(java.util.List<ExprNode> expressions)

replaceChildNode

public static void replaceChildNode(ExprNode parentNode,
                                    ExprNode nodeToReplace,
                                    ExprNode newNode)

toExpressionStringParameterList

public static void toExpressionStringParameterList(java.util.List<ExprNode> parameters,
                                                   java.io.StringWriter buffer)

toExpressionString

public static void toExpressionString(ExprNode node,
                                      java.io.StringWriter buffer)

toExpressionStringIncludeParen

public static void toExpressionStringIncludeParen(java.util.List<ExprNode> parameters,
                                                  java.io.StringWriter buffer)

printEvaluators

public static java.lang.String printEvaluators(ExprEvaluator[] evaluators)

acceptParams

public static void acceptParams(ExprNodeVisitor visitor,
                                java.util.List<ExprNode> params)

acceptParams

public static void acceptParams(ExprNodeVisitorWithParent visitor,
                                java.util.List<ExprNode> params)

acceptParams

public static void acceptParams(ExprNodeVisitorWithParent visitor,
                                java.util.List<ExprNode> params,
                                ExprNode parent)

getExprIdentNode

public static ExprIdentNode getExprIdentNode(EventType[] typesPerStream,
                                             int streamId,
                                             java.lang.String property)