public void Init(
int?streamOfProviderIfApplicable,
EnumMethodEnum enumMethodEnum,
String enumMethodUsedName,
EPType typeInfo,
IList <ExprNode> parameters,
ExprValidationContext validationContext)
{
var eventTypeColl = EPTypeHelper.GetEventTypeMultiValued(typeInfo);
var eventTypeBean = EPTypeHelper.GetEventTypeSingleValued(typeInfo);
var collectionComponentType = EPTypeHelper.GetClassMultiValued(typeInfo);
_enumMethodEnum = enumMethodEnum;
_enumMethodUsedName = enumMethodUsedName;
_streamCountIncoming = validationContext.StreamTypeService.EventTypes.Length;
if (eventTypeColl == null && collectionComponentType == null && eventTypeBean == null)
{
throw new ExprValidationException(
"Invalid input for built-in enumeration method '" + enumMethodUsedName +
"', expecting collection of event-type or scalar values as input, received " +
EPTypeHelper.ToTypeDescriptive(typeInfo));
}
// compile parameter abstract for validation against available footprints
var footprintProvided = DotMethodUtil.GetProvidedFootprint(parameters);
// validate parameters
DotMethodInputTypeMatcher inputTypeMatcher = new ProxyDotMethodInputTypeMatcher
{
ProcMatches = fp =>
{
if (fp.Input == DotMethodFPInputEnum.EVENTCOLL && eventTypeBean == null && eventTypeColl == null)
{
return(false);
}
if (fp.Input == DotMethodFPInputEnum.SCALAR_ANY && collectionComponentType == null)
{
return(false);
}
return(true);
}
};
var footprint = DotMethodUtil.ValidateParametersDetermineFootprint(
enumMethodEnum.GetFootprints(), DotMethodTypeEnum.ENUM, enumMethodUsedName, footprintProvided,
inputTypeMatcher);
// validate input criteria met for this footprint
if (footprint.Input != DotMethodFPInputEnum.ANY)
{
var message = "Invalid input for built-in enumeration method '" + enumMethodUsedName + "' and " +
footprint.Parameters.Length + "-parameter footprint, expecting collection of ";
var received = " as input, received " + EPTypeHelper.ToTypeDescriptive(typeInfo);
if (footprint.Input == DotMethodFPInputEnum.EVENTCOLL && eventTypeColl == null)
{
throw new ExprValidationException(message + "events" + received);
}
if (footprint.Input.IsScalar() && collectionComponentType == null)
{
throw new ExprValidationException(message + "values (typically scalar values)" + received);
}
if (footprint.Input == DotMethodFPInputEnum.SCALAR_NUMERIC && !collectionComponentType.IsNumeric())
{
throw new ExprValidationException(message + "numeric values" + received);
}
}
// manage context of this lambda-expression in regards to outer lambda-expression that may call this one.
ExpressionResultCacheForEnumerationMethod enumerationMethodCache = validationContext.ExprEvaluatorContext.ExpressionResultCacheService.AllocateEnumerationMethod;
enumerationMethodCache.PushStack(this);
var bodiesAndParameters = new List <ExprDotEvalParam>();
var count = 0;
var inputEventType = eventTypeBean ?? eventTypeColl;
foreach (var node in parameters)
{
var bodyAndParameter = GetBodyAndParameter(
enumMethodUsedName, count++, node, inputEventType, collectionComponentType, validationContext,
bodiesAndParameters, footprint);
bodiesAndParameters.Add(bodyAndParameter);
}
_enumEval = GetEnumEval(
validationContext.EngineImportService, validationContext.EventAdapterService,
validationContext.StreamTypeService, validationContext.StatementId, enumMethodUsedName,
bodiesAndParameters, inputEventType, collectionComponentType, _streamCountIncoming,
validationContext.IsDisablePropertyExpressionEventCollCache);
_enumEvalNumRequiredEvents = _enumEval.StreamNumSize;
// determine the stream ids of event properties asked for in the Evaluator(s)
var streamsRequired = new HashSet <int>();
var visitor = new ExprNodeIdentifierCollectVisitor();
foreach (var desc in bodiesAndParameters)
{
desc.Body.Accept(visitor);
foreach (var ident in visitor.ExprProperties)
{
streamsRequired.Add(ident.StreamId);
}
}
if (streamOfProviderIfApplicable != null)
{
streamsRequired.Add(streamOfProviderIfApplicable.Value);
}
// We turn on caching if the stack is not empty (we are an inner lambda) and the dependency does not include the stream.
var isInner = !enumerationMethodCache.PopLambda();
if (isInner)
{
// If none of the properties that the current lambda uses comes from the ultimate Parent(s) or subsequent streams, then cache.
var parents = enumerationMethodCache.GetStack();
var found = false;
foreach (var req in streamsRequired)
{
var first = (ExprDotEvalEnumMethodBase)parents.First;
var parentIncoming = first._streamCountIncoming - 1;
var selfAdded = _streamCountIncoming; // the one we use ourselfs
if (req > parentIncoming && req < selfAdded)
{
found = true;
}
}
_cache = !found;
}
}
public static ExprDotEvalDTMethodDesc ValidateMake(
StreamTypeService streamTypeService,
Deque <ExprChainedSpec> chainSpecStack,
DatetimeMethodEnum dtMethod,
String dtMethodName,
EPType inputType,
IList <ExprNode> parameters,
ExprDotNodeFilterAnalyzerInput inputDesc,
TimeZoneInfo timeZone)
{
// verify input
String message = "Date-time enumeration method '" + dtMethodName +
"' requires either a DateTime or long value as input or events of an event type that declares a timestamp property";
if (inputType is EventEPType)
{
if (((EventEPType)inputType).EventType.StartTimestampPropertyName == null)
{
throw new ExprValidationException(message);
}
}
else
{
if (!(inputType is ClassEPType || inputType is NullEPType))
{
throw new ExprValidationException(message + " but received " + EPTypeHelper.ToTypeDescriptive(inputType));
}
if (inputType is ClassEPType)
{
ClassEPType classEPType = (ClassEPType)inputType;
if (!TypeHelper.IsDateTime(classEPType.Clazz))
{
throw new ExprValidationException(
message + " but received " + classEPType.Clazz.GetTypeNameFullyQualPretty());
}
}
}
IList <CalendarOp> calendarOps = new List <CalendarOp>();
ReformatOp reformatOp = null;
IntervalOp intervalOp = null;
DatetimeMethodEnum currentMethod = dtMethod;
IList <ExprNode> currentParameters = parameters;
String currentMethodName = dtMethodName;
// drain all calendar ops
ExprDotNodeFilterAnalyzerDesc filterAnalyzerDesc = null;
while (true)
{
// handle the first one only if its a calendar op
var evaluators = GetEvaluators(currentParameters);
var opFactory = currentMethod.MetaData().OpFactory;
// compile parameter abstract for validation against available footprints
var footprintProvided = DotMethodUtil.GetProvidedFootprint(currentParameters);
// validate parameters
DotMethodUtil.ValidateParametersDetermineFootprint(
currentMethod.Footprints(),
DotMethodTypeEnum.DATETIME,
currentMethodName, footprintProvided,
DotMethodInputTypeMatcherImpl.DEFAULT_ALL);
if (opFactory is CalendarOpFactory)
{
CalendarOp calendarOp = ((CalendarOpFactory)opFactory).GetOp(currentMethod, currentMethodName, currentParameters, evaluators);
calendarOps.Add(calendarOp);
}
else if (opFactory is ReformatOpFactory)
{
reformatOp = ((ReformatOpFactory)opFactory).GetOp(timeZone, currentMethod, currentMethodName, currentParameters);
// compile filter analyzer information if there are no calendar ops in the chain
if (calendarOps.IsEmpty())
{
filterAnalyzerDesc = reformatOp.GetFilterDesc(streamTypeService.EventTypes, currentMethod, currentParameters, inputDesc);
}
else
{
filterAnalyzerDesc = null;
}
}
else if (opFactory is IntervalOpFactory)
{
intervalOp = ((IntervalOpFactory)opFactory).GetOp(streamTypeService, currentMethod, currentMethodName, currentParameters, evaluators);
// compile filter analyzer information if there are no calendar ops in the chain
if (calendarOps.IsEmpty())
{
filterAnalyzerDesc = intervalOp.GetFilterDesc(streamTypeService.EventTypes, currentMethod, currentParameters, inputDesc);
}
else
{
filterAnalyzerDesc = null;
}
}
else
{
throw new IllegalStateException("Invalid op factory class " + opFactory);
}
// see if there is more
if (chainSpecStack.IsEmpty() || !DatetimeMethodEnumExtensions.IsDateTimeMethod(chainSpecStack.First.Name))
{
break;
}
// pull next
var next = chainSpecStack.RemoveFirst();
currentMethod = DatetimeMethodEnumExtensions.FromName(next.Name);
currentParameters = next.Parameters;
currentMethodName = next.Name;
if ((reformatOp != null || intervalOp != null))
{
throw new ExprValidationException("Invalid input for date-time method '" + next.Name + "'");
}
}
ExprDotEval dotEval;
EPType returnType;
dotEval = new ExprDotEvalDT(calendarOps, timeZone, reformatOp, intervalOp, EPTypeHelper.GetClassSingleValued(inputType), EPTypeHelper.GetEventTypeSingleValued(inputType));
returnType = dotEval.TypeInfo;
return(new ExprDotEvalDTMethodDesc(dotEval, returnType, filterAnalyzerDesc));
}
