public void Init(
int? streamOfProviderIfApplicable,
EnumMethodEnum enumMethodEnum,
string enumMethodUsedName,
EPType typeInfo,
IList<ExprNode> parameters,
ExprValidationContext validationContext)
{
var eventTypeColl = typeInfo.GetEventTypeMultiValued();
var eventTypeBean = typeInfo.GetEventTypeSingleValued();
var collectionComponentType = typeInfo.GetClassMultiValued();
this.enumMethodEnum = enumMethodEnum;
this.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 " +
typeInfo.ToTypeDescriptive());
}
// compile parameter abstract for validation against available footprints
DotMethodFPProvided 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;
}
};
DotMethodFP 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.
var enumCallStackHelper = validationContext.EnumMethodCallStackHelper;
enumCallStackHelper.PushStack(this);
IList<ExprDotEvalParam> bodiesAndParameters = new List<ExprDotEvalParam>();
var count = 0;
var inputEventType = eventTypeBean == null ? eventTypeColl : eventTypeBean;
foreach (var node in parameters) {
var bodyAndParameter = GetBodyAndParameter(
enumMethodUsedName,
count++,
node,
inputEventType,
collectionComponentType,
validationContext,
bodiesAndParameters,
footprint);
bodiesAndParameters.Add(bodyAndParameter);
}
enumForge = GetEnumForge(
validationContext.StreamTypeService,
enumMethodUsedName,
bodiesAndParameters,
inputEventType, // TBD: collectionType, may not be applicable
collectionComponentType,
streamCountIncoming,
validationContext.IsDisablePropertyExpressionEventCollCache,
validationContext.StatementRawInfo,
validationContext.StatementCompileTimeService);
enumEvalNumRequiredEvents = enumForge.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 = !enumCallStackHelper.PopLambda();
if (isInner) {
// If none of the properties that the current lambda uses comes from the ultimate parent(s) or subsequent streams, then cache.
Deque<ExpressionResultCacheStackEntry> parents = enumCallStackHelper.GetStack();
var found = false;
foreach (var req in streamsRequired) {
var first = (ExprDotForgeEnumMethodBase) 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 ExprDotDTMethodDesc ValidateMake(
StreamTypeService streamTypeService,
Deque<ExprChainedSpec> chainSpecStack,
DateTimeMethodEnum dtMethod,
string dtMethodName,
EPType inputType,
IList<ExprNode> parameters,
ExprDotNodeFilterAnalyzerInput inputDesc,
TimeAbacus timeAbacus,
ExprEvaluatorContext exprEvaluatorContext,
TableCompileTimeResolver tableCompileTimeResolver)
{
// verify input
var message = "Date-time enumeration method '" +
dtMethodName +
"' requires either a DateTimeEx, DateTimeOffset, 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 " + inputType.ToTypeDescriptive());
}
if (inputType is ClassEPType) {
var classEPType = (ClassEPType) inputType;
if (!TypeHelper.IsDateTime(classEPType.Clazz)) {
throw new ExprValidationException(
message + " but received " + classEPType.Clazz.CleanName());
}
}
}
IList<CalendarForge> calendarForges = new List<CalendarForge>();
ReformatForge reformatForge = null;
IntervalForge intervalForge = null;
var currentMethod = dtMethod;
var currentParameters = parameters;
var currentMethodName = dtMethodName;
// drain all calendar op
FilterExprAnalyzerAffector filterAnalyzerDesc = null;
while (true) {
// handle the first one only if its a calendar op
var forges = GetForges(currentParameters);
var opFactory = currentMethod.GetForgeFactory();
// compile parameter abstract for validation against available footprints
DotMethodFPProvided footprintProvided = DotMethodUtil.GetProvidedFootprint(currentParameters);
// validate parameters
DotMethodUtil.ValidateParametersDetermineFootprint(
currentMethod.GetFootprints(),
DotMethodTypeEnum.DATETIME,
currentMethodName,
footprintProvided,
DotMethodInputTypeMatcherImpl.DEFAULT_ALL);
if (opFactory is CalendarForgeFactory) {
var calendarForge = ((CalendarForgeFactory) currentMethod.GetForgeFactory()).GetOp(
currentMethod,
currentMethodName,
currentParameters,
forges);
calendarForges.Add(calendarForge);
}
else if (opFactory is ReformatForgeFactory) {
reformatForge = ((ReformatForgeFactory) opFactory).GetForge(
inputType,
timeAbacus,
currentMethod,
currentMethodName,
currentParameters,
exprEvaluatorContext);
// compile filter analyzer information if there are no calendar op in the chain
if (calendarForges.IsEmpty()) {
filterAnalyzerDesc = reformatForge.GetFilterDesc(
streamTypeService.EventTypes,
currentMethod,
currentParameters,
inputDesc);
}
else {
filterAnalyzerDesc = null;
}
}
else if (opFactory is IntervalForgeFactory) {
intervalForge = ((IntervalForgeFactory) opFactory).GetForge(
streamTypeService,
currentMethod,
currentMethodName,
currentParameters,
timeAbacus,
tableCompileTimeResolver);
// compile filter analyzer information if there are no calendar op in the chain
if (calendarForges.IsEmpty()) {
filterAnalyzerDesc = intervalForge.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() || !DatetimeMethodEnumHelper.IsDateTimeMethod(chainSpecStack.First.Name)) {
break;
}
// pull next
var next = chainSpecStack.RemoveFirst();
currentMethod = DatetimeMethodEnumHelper.FromName(next.Name);
currentParameters = next.Parameters;
currentMethodName = next.Name;
if (reformatForge != null || intervalForge != null) {
throw new ExprValidationException("Invalid input for date-time method '" + next.Name + "'");
}
}
ExprDotForge dotForge;
EPType returnType;
dotForge = new ExprDotDTForge(
calendarForges,
timeAbacus,
reformatForge,
intervalForge,
inputType.GetClassSingleValued(),
inputType.GetEventTypeSingleValued());
returnType = dotForge.TypeInfo;
return new ExprDotDTMethodDesc(dotForge, returnType, filterAnalyzerDesc);
}
