public object Evaluate(
EventBean[] eventsPerStream,
bool isNewData,
ExprEvaluatorContext exprEvaluatorContext)
{
throw ExprNodeUtilityMake.MakeUnsupportedCompileTime();
}
/// <summary>
/// Validates the expression node subtree that has this
/// node as root. Some of the nodes of the tree, including the
/// root, might be replaced in the process.
/// </summary>
/// <param name="origin">validate origin</param>
/// <param name="exprNode">node</param>
/// <param name="validationContext">context</param>
/// <returns>the root node of the validated subtree, possibly different than the root node of the unvalidated subtree
/// </returns>
/// <throws>ExprValidationException when the validation fails</throws>
public static ExprNode GetValidatedSubtree(
ExprNodeOrigin origin,
ExprNode exprNode,
ExprValidationContext validationContext)
{
if (exprNode is ExprLambdaGoesNode) {
return exprNode;
}
try {
return GetValidatedSubtreeInternal(exprNode, validationContext, true);
}
catch (ExprValidationException ex) {
try {
string text;
if (exprNode is ExprSubselectNode subselect) {
text = ExprNodeUtilityMake.GetSubqueryInfoText(subselect);
}
else {
text = ExprNodeUtilityPrint.ToExpressionStringMinPrecedenceSafe(exprNode);
if (text.Length > 40) {
string shortened = text.Substring(0, 35);
text = shortened + "...(" + text.Length + " chars)";
}
text = "'" + text + "'";
}
var errorText = string.Format(
"Failed to validate {0} expression {1}: {2}",
origin.GetClauseName(),
text,
ex.Message);
throw new ExprValidationException(errorText, ex);
}
catch (ExprValidationException) {
throw;
}
catch (EPException) {
throw;
}
catch (Exception rtex) {
Log.Debug("Failed to render nice validation message text: " + rtex.Message, rtex);
// fall through
}
throw;
}
}
public static ExprNodeUtilMethodDesc ResolveMethodAllowWildcardAndStream(
string className,
Type optionalClass,
string methodName,
IList<ExprNode> parameters,
bool allowWildcard,
EventType wildcardType,
ExprNodeUtilResolveExceptionHandler exceptionHandler,
string functionName,
StatementRawInfo statementRawInfo,
StatementCompileTimeServices services)
{
var paramTypes = new Type[parameters.Count];
var childForges = new ExprForge[parameters.Count];
var count = 0;
var allowEventBeanType = new bool[parameters.Count];
var allowEventBeanCollType = new bool[parameters.Count];
var childEvalsEventBeanReturnTypesForges = new ExprForge[parameters.Count];
var allConstants = true;
foreach (var childNode in parameters) {
if (!EnumMethodResolver.IsEnumerationMethod(methodName, services.ImportServiceCompileTime) && childNode is ExprLambdaGoesNode) {
throw new ExprValidationException(
"Unrecognized lambda-expression encountered as parameter to UDF or static method '" +
methodName +
"'");
}
if (childNode is ExprWildcard) {
if (wildcardType == null || !allowWildcard) {
throw new ExprValidationException("Failed to resolve wildcard parameter to a given event type");
}
childForges[count] = new ExprEvalStreamNumUnd(0, wildcardType.UnderlyingType);
childEvalsEventBeanReturnTypesForges[count] = new ExprEvalStreamNumEvent(0);
paramTypes[count] = wildcardType.UnderlyingType;
allowEventBeanType[count] = true;
allConstants = false;
count++;
continue;
}
if (childNode is ExprStreamUnderlyingNode) {
var und = (ExprStreamUnderlyingNode) childNode;
var tableMetadata = services.TableCompileTimeResolver.ResolveTableFromEventType(und.EventType);
if (tableMetadata == null) {
childForges[count] = childNode.Forge;
childEvalsEventBeanReturnTypesForges[count] = new ExprEvalStreamNumEvent(und.StreamId);
}
else {
childForges[count] = new ExprEvalStreamTable(
und.StreamId,
und.EventType.UnderlyingType,
tableMetadata);
childEvalsEventBeanReturnTypesForges[count] =
new ExprEvalStreamNumEventTable(und.StreamId, tableMetadata);
}
paramTypes[count] = childForges[count].EvaluationType;
allowEventBeanType[count] = true;
allConstants = false;
count++;
continue;
}
if (childNode.Forge is ExprEnumerationForge) {
var enumeration = (ExprEnumerationForge) childNode.Forge;
var eventType = enumeration.GetEventTypeSingle(statementRawInfo, services);
childForges[count] = childNode.Forge;
paramTypes[count] = childForges[count].EvaluationType;
allConstants = false;
if (eventType != null) {
childEvalsEventBeanReturnTypesForges[count] = new ExprEvalStreamNumEnumSingleForge(enumeration);
allowEventBeanType[count] = true;
count++;
continue;
}
var eventTypeColl = enumeration.GetEventTypeCollection(statementRawInfo, services);
if (eventTypeColl != null) {
childEvalsEventBeanReturnTypesForges[count] = new ExprEvalStreamNumEnumCollForge(enumeration);
allowEventBeanCollType[count] = true;
count++;
continue;
}
}
paramTypes[count] = childNode.Forge.EvaluationType;
childForges[count] = childNode.Forge;
count++;
if (!childNode.Forge.ForgeConstantType.IsCompileTimeConstant) {
allConstants = false;
}
}
// Try to resolve the method
MethodInfo method;
try {
if (optionalClass != null) {
method = services.ImportServiceCompileTime.ResolveMethod(
optionalClass,
methodName,
paramTypes,
allowEventBeanType);
}
else {
method = services.ImportServiceCompileTime.ResolveMethodOverloadChecked(
className,
methodName,
paramTypes,
allowEventBeanType,
allowEventBeanCollType,
services.ClassProvidedExtension);
}
}
catch (Exception e) {
throw exceptionHandler.Handle(e);
}
var parameterTypes = method.GetParameterTypes();
// rewrite those evaluator that should return the event itself
if (CollectionUtil.IsAnySet(allowEventBeanType)) {
for (var i = 0; i < parameters.Count; i++) {
if (allowEventBeanType[i] && parameterTypes[i] == typeof(EventBean)) {
childForges[i] = childEvalsEventBeanReturnTypesForges[i];
}
}
}
// rewrite those evaluators that should return the event collection
if (CollectionUtil.IsAnySet(allowEventBeanCollType)) {
for (var i = 0; i < parameters.Count; i++) {
if (allowEventBeanCollType[i] && (parameterTypes[i] == typeof(ICollection<EventBean>))) {
childForges[i] = childEvalsEventBeanReturnTypesForges[i];
}
}
}
// add an evaluator if the method expects a context object
if (!method.IsVarArgs() &&
parameterTypes.Length > 0 &&
parameterTypes[parameterTypes.Length - 1] == typeof(EPLMethodInvocationContext)) {
var node = new ExprEvalMethodContext(functionName);
childForges = (ExprForge[]) CollectionUtil.ArrayExpandAddSingle(childForges, node);
}
// handle varargs
if (method.IsVarArgs()) {
// handle context parameter
var numMethodParams = parameterTypes.Length;
if (numMethodParams > 1 && parameterTypes[numMethodParams - 2] == typeof(EPLMethodInvocationContext)) {
var rewrittenForges = new ExprForge[childForges.Length + 1];
Array.Copy(childForges, 0, rewrittenForges, 0, numMethodParams - 2);
rewrittenForges[numMethodParams - 2] = new ExprEvalMethodContext(functionName);
Array.Copy(
childForges,
numMethodParams - 2,
rewrittenForges,
numMethodParams - 1,
childForges.Length - (numMethodParams - 2));
childForges = rewrittenForges;
}
childForges = ExprNodeUtilityMake.MakeVarargArrayForges(method, childForges);
}
var localInlinedClass = services.ClassProvidedExtension.IsLocalInlinedClass(method.DeclaringType);
return new ExprNodeUtilMethodDesc(allConstants, childForges, method, localInlinedClass);
}
