public FilterExprAnalyzerAffector GetFilterDesc(
EventType[] typesPerStream,
DatetimeMethodEnum currentMethod,
IList <ExprNode> currentParameters,
ExprDotNodeFilterAnalyzerInput inputDesc)
{
if (_includeLow == null || _includeHigh == null)
{
return(null);
}
int targetStreamNum;
string targetProperty;
if (inputDesc is ExprDotNodeFilterAnalyzerInputStream)
{
var targetStream = (ExprDotNodeFilterAnalyzerInputStream)inputDesc;
targetStreamNum = targetStream.StreamNum;
var targetType = typesPerStream[targetStreamNum];
targetProperty = targetType.StartTimestampPropertyName;
}
else if (inputDesc is ExprDotNodeFilterAnalyzerInputProp)
{
var targetStream = (ExprDotNodeFilterAnalyzerInputProp)inputDesc;
targetStreamNum = targetStream.StreamNum;
targetProperty = targetStream.PropertyName;
}
else
{
return(null);
}
return(new FilterExprAnalyzerDTBetweenAffector(
typesPerStream, targetStreamNum, targetProperty, _start, _end, _includeLow.Value, _includeHigh.Value));
}
public ExprDotNodeFilterAnalyzerDesc GetFilterDesc(EventType[] typesPerStream,
DatetimeMethodEnum currentMethod,
ICollection <ExprNode> currentParameters,
ExprDotNodeFilterAnalyzerInput inputDesc)
{
if (_includeLow == null || _includeHigh == null)
{
return(null);
}
int targetStreamNum;
String targetProperty;
if (inputDesc is ExprDotNodeFilterAnalyzerInputStream)
{
var targetStream = (ExprDotNodeFilterAnalyzerInputStream)inputDesc;
targetStreamNum = targetStream.StreamNum;
EventType targetType = typesPerStream[targetStreamNum];
targetProperty = targetType.StartTimestampPropertyName;
}
else if (inputDesc is ExprDotNodeFilterAnalyzerInputProp)
{
var targetStream = (ExprDotNodeFilterAnalyzerInputProp)inputDesc;
targetStreamNum = targetStream.StreamNum;
targetProperty = targetStream.PropertyName;
}
else
{
return(null);
}
return(new ExprDotNodeFilterAnalyzerDTBetweenDesc(typesPerStream, targetStreamNum, targetProperty, _start,
_end, _includeLow.GetValueOrDefault(),
_includeHigh.GetValueOrDefault()));
}
public ExprDotNodeFilterAnalyzerDesc GetFilterDesc(EventType[] typesPerStream,
DatetimeMethodEnum currentMethod,
ICollection <ExprNode> currentParameters,
ExprDotNodeFilterAnalyzerInput inputDesc)
{
return(null);
}
public ReformatOp GetOp(TimeZoneInfo timeZone, DatetimeMethodEnum method, String methodNameUsed, IList <ExprNode> parameters)
{
switch (method)
{
case DatetimeMethodEnum.GET:
return(new ReformatOpGetField(CalendarOpUtil.GetEnum(methodNameUsed, parameters[0]), timeZone));
case DatetimeMethodEnum.FORMAT:
return(FormatString);
case DatetimeMethodEnum.TOMILLISEC:
return(ToMsec);
case DatetimeMethodEnum.TODATE:
return(new ReformatOpToDateTime(timeZone));
case DatetimeMethodEnum.TOCALENDAR:
return(new ReformatOpToDateTime(timeZone));
case DatetimeMethodEnum.GETDAYOFMONTH:
return(new ReformatOpDateTimeEval(DateTimeEvalStatics.DayOfMonth, typeof(int), timeZone));
case DatetimeMethodEnum.GETMINUTEOFHOUR:
return(new ReformatOpDateTimeEval(DateTimeEvalStatics.MinuteOfHour, typeof(int), timeZone));
case DatetimeMethodEnum.GETMONTHOFYEAR:
return(new ReformatOpDateTimeEval(DateTimeEvalStatics.MonthOfYear, typeof(int), timeZone));
case DatetimeMethodEnum.GETDAYOFWEEK:
return(new ReformatOpDateTimeEval(DateTimeEvalStatics.DayOfWeek, typeof(DayOfWeek), timeZone));
case DatetimeMethodEnum.GETDAYOFYEAR:
return(new ReformatOpDateTimeEval(DateTimeEvalStatics.DayOfYear, typeof(int), timeZone));
case DatetimeMethodEnum.GETHOUROFDAY:
return(new ReformatOpDateTimeEval(DateTimeEvalStatics.HourOfDay, typeof(int), timeZone));
case DatetimeMethodEnum.GETMILLISOFSECOND:
return(new ReformatOpDateTimeEval(DateTimeEvalStatics.MillisOfSecond, typeof(int), timeZone));
case DatetimeMethodEnum.GETSECONDOFMINUTE:
return(new ReformatOpDateTimeEval(DateTimeEvalStatics.SecondOfMinute, typeof(int), timeZone));
case DatetimeMethodEnum.GETWEEKYEAR:
return(new ReformatOpDateTimeEval(DateTimeEvalStatics.Weekyear, typeof(int), timeZone));
case DatetimeMethodEnum.GETYEAR:
return(new ReformatOpDateTimeEval(DateTimeEvalStatics.Year, typeof(int), timeZone));
case DatetimeMethodEnum.BETWEEN:
if (ExprNodeUtility.IsAllConstants(parameters))
{
return(new ReformatOpBetweenConstantParams(parameters));
}
return(new ReformatOpBetweenNonConstantParams(parameters));
}
throw new IllegalStateException("Unrecognized date-time method code '" + method + "'");
}
public FilterExprAnalyzerAffector GetFilterDesc(
EventType[] typesPerStream,
DatetimeMethodEnum currentMethod,
IList <ExprNode> currentParameters,
ExprDotNodeFilterAnalyzerInput inputDesc)
{
return(null);
}
public IntervalOp GetOp(
StreamTypeService streamTypeService,
DatetimeMethodEnum method,
string methodNameUsed,
IList <ExprNode> parameters,
TimeZoneInfo timeZone,
TimeAbacus timeAbacus)
{
return(new IntervalOpImpl(method, methodNameUsed, streamTypeService, parameters, timeZone, timeAbacus));
}
public static DotMethodFP[] Footprints(this DatetimeMethodEnum datetimeMethodEnum)
{
var metaData = MetaData(datetimeMethodEnum);
if (metaData != null)
{
return(metaData.Footprints);
}
throw new ArgumentException();
}
public FilterExprAnalyzerDTIntervalAffector(DatetimeMethodEnum currentMethod, EventType[] typesPerStream, int targetStreamNum, String targetStartProp, String targetEndProp, int?parameterStreamNum, String parameterStartProp, String parameterEndProp)
{
_currentMethod = currentMethod;
_typesPerStream = typesPerStream;
_targetStreamNum = targetStreamNum;
_targetStartProp = targetStartProp;
_targetEndProp = targetEndProp;
_parameterStreamNum = parameterStreamNum;
_parameterStartProp = parameterStartProp;
_parameterEndProp = parameterEndProp;
}
/// <summary>
/// Obtain information used by filter analyzer to handle this dot-method invocation as part of query planning/indexing.
/// </summary>
/// <param name="typesPerStream">The types per stream.</param>
/// <param name="currentMethod">The current method.</param>
/// <param name="currentParameters">The current parameters.</param>
/// <param name="inputDesc">The input desc.</param>
/// <returns></returns>
public FilterExprAnalyzerDTIntervalAffector GetFilterDesc(
EventType[] typesPerStream,
DatetimeMethodEnum currentMethod,
IList <ExprNode> currentParameters,
ExprDotNodeFilterAnalyzerInput inputDesc)
{
// with intervals is not currently query planned
if (currentParameters.Count > 1)
{
return(null);
}
// Get input (target)
int targetStreamNum;
String targetPropertyStart;
String targetPropertyEnd;
if (inputDesc is ExprDotNodeFilterAnalyzerInputStream)
{
var targetStream = (ExprDotNodeFilterAnalyzerInputStream)inputDesc;
targetStreamNum = targetStream.StreamNum;
EventType targetType = typesPerStream[targetStreamNum];
targetPropertyStart = targetType.StartTimestampPropertyName;
targetPropertyEnd = targetType.EndTimestampPropertyName ?? targetPropertyStart;
}
else if (inputDesc is ExprDotNodeFilterAnalyzerInputProp)
{
var targetStream = (ExprDotNodeFilterAnalyzerInputProp)inputDesc;
targetStreamNum = targetStream.StreamNum;
targetPropertyStart = targetStream.PropertyName;
targetPropertyEnd = targetStream.PropertyName;
}
else
{
return(null);
}
// check parameter info
if (_parameterPropertyStart == null)
{
return(null);
}
return(new FilterExprAnalyzerDTIntervalAffector(currentMethod, typesPerStream,
targetStreamNum, targetPropertyStart, targetPropertyEnd,
_parameterStreamNum, _parameterPropertyStart, _parameterPropertyEnd));
}
public CalendarOpRound(CalendarFieldEnum fieldName, DatetimeMethodEnum method)
{
_fieldName = fieldName;
if (method == DatetimeMethodEnum.ROUNDCEILING)
{
_code = ApacheCommonsDateUtils.MODIFY_CEILING;
}
else if (method == DatetimeMethodEnum.ROUNDFLOOR)
{
_code = ApacheCommonsDateUtils.MODIFY_TRUNCATE;
}
else if (method == DatetimeMethodEnum.ROUNDHALF)
{
_code = ApacheCommonsDateUtils.MODIFY_ROUND;
}
else
{
throw new ArgumentException("Unrecognized method '" + method + "'");
}
}
public CalendarOp GetOp(DatetimeMethodEnum method, String methodNameUsed, IList <ExprNode> parameters, ExprEvaluator[] evaluators)
{
if (method == DatetimeMethodEnum.WITHTIME)
{
return(new CalendarOpWithTime(evaluators[0], evaluators[1], evaluators[2], evaluators[3]));
}
if (method == DatetimeMethodEnum.WITHDATE)
{
return(new CalendarOpWithDate(evaluators[0], evaluators[1], evaluators[2]));
}
if (method == DatetimeMethodEnum.PLUS || method == DatetimeMethodEnum.MINUS)
{
return(new CalendarOpPlusMinus(evaluators[0], method == DatetimeMethodEnum.MINUS ? -1 : 1));
}
if (method == DatetimeMethodEnum.WITHMAX ||
method == DatetimeMethodEnum.WITHMIN ||
method == DatetimeMethodEnum.ROUNDCEILING ||
method == DatetimeMethodEnum.ROUNDFLOOR ||
method == DatetimeMethodEnum.ROUNDHALF ||
method == DatetimeMethodEnum.SET)
{
CalendarFieldEnum fieldNum = CalendarOpUtil.GetEnum(methodNameUsed, parameters[0]);
if (method == DatetimeMethodEnum.WITHMIN)
{
return(new CalendarOpWithMin(fieldNum));
}
if (method == DatetimeMethodEnum.ROUNDCEILING || method == DatetimeMethodEnum.ROUNDFLOOR || method == DatetimeMethodEnum.ROUNDHALF)
{
return(new CalendarOpRound(fieldNum, method));
}
if (method == DatetimeMethodEnum.SET)
{
return(new CalendarOpSet(fieldNum, evaluators[1]));
}
return(new CalendarOpWithMax(fieldNum));
}
throw new IllegalStateException("Unrecognized calendar-op code '" + method + "'");
}
public static DatetimeMethodEnumMetaData MetaData(this DatetimeMethodEnum datetimeMethodEnum)
{
return(MetaDataTable.Get(datetimeMethodEnum));
}
public IntervalOp GetOp(StreamTypeService streamTypeService, DatetimeMethodEnum method, String methodNameUsed, IList <ExprNode> parameters, ExprEvaluator[] evaluators)
{
return(new IntervalOpImpl(method, methodNameUsed, streamTypeService, parameters));
}
public IntervalOpImpl(DatetimeMethodEnum method, String methodNameUse, StreamTypeService streamTypeService, IList <ExprNode> expressions)
{
ExprEvaluator evaluatorEndTimestamp = null;
Type timestampType;
if (expressions[0] is ExprStreamUnderlyingNode)
{
var und = (ExprStreamUnderlyingNode)expressions[0];
_parameterStreamNum = und.StreamId;
EventType type = streamTypeService.EventTypes[_parameterStreamNum];
_parameterPropertyStart = type.StartTimestampPropertyName;
if (_parameterPropertyStart == null)
{
throw new ExprValidationException("For date-time method '" + methodNameUse + "' the first parameter is event type '" + type.Name + "', however no timestamp property has been defined for this event type");
}
timestampType = type.GetPropertyType(_parameterPropertyStart);
EventPropertyGetter getter = type.GetGetter(_parameterPropertyStart);
_evaluatorTimestamp = new ExprEvaluatorStreamLongProp(_parameterStreamNum, getter);
if (type.EndTimestampPropertyName != null)
{
_parameterPropertyEnd = type.EndTimestampPropertyName;
EventPropertyGetter getterEndTimestamp = type.GetGetter(type.EndTimestampPropertyName);
evaluatorEndTimestamp = new ExprEvaluatorStreamLongProp(_parameterStreamNum, getterEndTimestamp);
}
else
{
_parameterPropertyEnd = _parameterPropertyStart;
}
}
else
{
_evaluatorTimestamp = expressions[0].ExprEvaluator;
timestampType = _evaluatorTimestamp.ReturnType;
String unresolvedPropertyName = null;
if (expressions[0] is ExprIdentNode)
{
var identNode = (ExprIdentNode)expressions[0];
_parameterStreamNum = identNode.StreamId;
_parameterPropertyStart = identNode.ResolvedPropertyName;
_parameterPropertyEnd = _parameterPropertyStart;
unresolvedPropertyName = identNode.UnresolvedPropertyName;
}
if (!_evaluatorTimestamp.ReturnType.IsDateTime())
{
// ident node may represent a fragment
if (unresolvedPropertyName != null)
{
var propertyDesc = ExprIdentNodeUtil.GetTypeFromStream(
streamTypeService, unresolvedPropertyName, false, true);
if (propertyDesc.First.FragmentEventType != null)
{
EventType type = propertyDesc.First.FragmentEventType.FragmentType;
_parameterPropertyStart = type.StartTimestampPropertyName;
if (_parameterPropertyStart == null)
{
throw new ExprValidationException("For date-time method '" + methodNameUse + "' the first parameter is event type '" + type.Name + "', however no timestamp property has been defined for this event type");
}
timestampType = type.GetPropertyType(_parameterPropertyStart);
EventPropertyGetter getterFragment = streamTypeService.EventTypes[_parameterStreamNum].GetGetter(unresolvedPropertyName);
EventPropertyGetter getterStartTimestamp = type.GetGetter(_parameterPropertyStart);
_evaluatorTimestamp = new ExprEvaluatorStreamLongPropFragment(_parameterStreamNum, getterFragment, getterStartTimestamp);
if (type.EndTimestampPropertyName != null)
{
_parameterPropertyEnd = type.EndTimestampPropertyName;
EventPropertyGetter getterEndTimestamp = type.GetGetter(type.EndTimestampPropertyName);
evaluatorEndTimestamp = new ExprEvaluatorStreamLongPropFragment(_parameterStreamNum, getterFragment, getterEndTimestamp);
}
else
{
_parameterPropertyEnd = _parameterPropertyStart;
}
}
}
else
{
throw new ExprValidationException("For date-time method '" + methodNameUse + "' the first parameter expression returns '" + _evaluatorTimestamp.ReturnType.FullName + "', however requires a DateTime or Long-type return value or event (with timestamp)");
}
}
}
IntervalComputer intervalComputer = IntervalComputerFactory.Make(method, expressions);
// evaluation without end timestamp
var timestampTypeBoxed = timestampType != null?timestampType.GetBoxedType() : timestampType;
if (evaluatorEndTimestamp == null)
{
if (timestampTypeBoxed == typeof(DateTime?) || timestampTypeBoxed == typeof(DateTimeOffset?))
{
_intervalOpEval = new IntervalOpEvalCal(intervalComputer);
}
else if (timestampTypeBoxed == typeof(long?))
{
_intervalOpEval = new IntervalOpEvalLong(intervalComputer);
}
else
{
throw new ArgumentException("Invalid interval first parameter type '" + timestampType + "'");
}
}
else
{
if (timestampTypeBoxed == typeof(DateTime?) || timestampTypeBoxed == typeof(DateTimeOffset?))
{
_intervalOpEval = new IntervalOpEvalCalWithEnd(intervalComputer, evaluatorEndTimestamp);
}
else if (timestampTypeBoxed == typeof(long?))
{
_intervalOpEval = new IntervalOpEvalLongWithEnd(intervalComputer, evaluatorEndTimestamp);
}
else
{
throw new ArgumentException("Invalid interval first parameter type '" + timestampType + "'");
}
}
}
public static IntervalComputer Make(DatetimeMethodEnum method, IList <ExprNode> expressions, TimeAbacus timeAbacus)
{
var parameters = GetParameters(expressions, timeAbacus);
if (method == DatetimeMethodEnum.BEFORE)
{
if (parameters.Length == 0)
{
return(new IntervalComputerBeforeNoParam());
}
var pair = IntervalStartEndParameterPair.FromParamsWithLongMaxEnd(parameters);
if (pair.IsConstant)
{
return(new IntervalComputerConstantBefore(pair));
}
return(new IntervalComputerBeforeWithDeltaExpr(pair));
}
else if (method == DatetimeMethodEnum.AFTER)
{
if (parameters.Length == 0)
{
return(new IntervalComputerAfterNoParam());
}
var pair = IntervalStartEndParameterPair.FromParamsWithLongMaxEnd(parameters);
if (pair.IsConstant)
{
return(new IntervalComputerConstantAfter(pair));
}
return(new IntervalComputerAfterWithDeltaExpr(pair));
}
else if (method == DatetimeMethodEnum.COINCIDES)
{
if (parameters.Length == 0)
{
return(new IntervalComputerCoincidesNoParam());
}
var pair = IntervalStartEndParameterPair.FromParamsWithSameEnd(parameters);
if (pair.IsConstant)
{
return(new IntervalComputerConstantCoincides(pair));
}
return(new IntervalComputerCoincidesWithDeltaExpr(pair));
}
else if (method == DatetimeMethodEnum.DURING || method == DatetimeMethodEnum.INCLUDES)
{
if (parameters.Length == 0)
{
if (method == DatetimeMethodEnum.DURING)
{
return(new IntervalComputerDuringNoParam());
}
return(new IntervalComputerIncludesNoParam());
}
var pair = IntervalStartEndParameterPair.FromParamsWithSameEnd(parameters);
if (parameters.Length == 1)
{
return(new IntervalComputerDuringAndIncludesThreshold(
method == DatetimeMethodEnum.DURING, pair.Start.Evaluator));
}
if (parameters.Length == 2)
{
return(new IntervalComputerDuringAndIncludesMinMax(
method == DatetimeMethodEnum.DURING, pair.Start.Evaluator, pair.End.Evaluator));
}
return(new IntervalComputerDuringMinMaxStartEnd(
method == DatetimeMethodEnum.DURING, GetEvaluators(expressions, timeAbacus)));
}
else if (method == DatetimeMethodEnum.FINISHES)
{
if (parameters.Length == 0)
{
return(new IntervalComputerFinishesNoParam());
}
ValidateConstantThreshold("finishes", parameters[0]);
return(new IntervalComputerFinishesThreshold(parameters[0].Evaluator));
}
else if (method == DatetimeMethodEnum.FINISHEDBY)
{
if (parameters.Length == 0)
{
return(new IntervalComputerFinishedByNoParam());
}
ValidateConstantThreshold("finishedby", parameters[0]);
return(new IntervalComputerFinishedByThreshold(parameters[0].Evaluator));
}
else if (method == DatetimeMethodEnum.MEETS)
{
if (parameters.Length == 0)
{
return(new IntervalComputerMeetsNoParam());
}
ValidateConstantThreshold("meets", parameters[0]);
return(new IntervalComputerMeetsThreshold(parameters[0].Evaluator));
}
else if (method == DatetimeMethodEnum.METBY)
{
if (parameters.Length == 0)
{
return(new IntervalComputerMetByNoParam());
}
ValidateConstantThreshold("metBy", parameters[0]);
return(new IntervalComputerMetByThreshold(parameters[0].Evaluator));
}
else if (method == DatetimeMethodEnum.OVERLAPS || method == DatetimeMethodEnum.OVERLAPPEDBY)
{
if (parameters.Length == 0)
{
if (method == DatetimeMethodEnum.OVERLAPS)
{
return(new IntervalComputerOverlapsNoParam());
}
return(new IntervalComputerOverlappedByNoParam());
}
if (parameters.Length == 1)
{
return(new IntervalComputerOverlapsAndByThreshold(
method == DatetimeMethodEnum.OVERLAPS, parameters[0].Evaluator));
}
return(new IntervalComputerOverlapsAndByMinMax(
method == DatetimeMethodEnum.OVERLAPS, parameters[0].Evaluator, parameters[1].Evaluator));
}
else if (method == DatetimeMethodEnum.STARTS)
{
if (parameters.Length == 0)
{
return(new IntervalComputerStartsNoParam());
}
ValidateConstantThreshold("starts", parameters[0]);
return(new IntervalComputerStartsThreshold(parameters[0].Evaluator));
}
else if (method == DatetimeMethodEnum.STARTEDBY)
{
if (parameters.Length == 0)
{
return(new IntervalComputerStartedByNoParam());
}
ValidateConstantThreshold("startedBy", parameters[0]);
return(new IntervalComputerStartedByThreshold(parameters[0].Evaluator));
}
throw new ArgumentException("Unknown datetime method '" + method + "'");
}
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));
}
public ReformatOp GetOp(
TimeZoneInfo timeZone,
TimeAbacus timeAbacus,
DatetimeMethodEnum method,
string methodNameUsed,
IList <ExprNode> parameters)
{
if (method == DatetimeMethodEnum.GET)
{
CalendarFieldEnum fieldNum = CalendarOpUtil.GetEnum(methodNameUsed, parameters[0]);
return(new ReformatOpGetField(fieldNum, timeZone, timeAbacus));
}
if (method == DatetimeMethodEnum.FORMAT)
{
return(FORMAT_STRING);
}
if (method == DatetimeMethodEnum.TOCALENDAR)
{
return(new ReformatOpToCalendar(timeZone, timeAbacus));
}
if (method == DatetimeMethodEnum.TOMILLISEC)
{
return(new ReformatOpToMillisec(timeZone));
}
if (method == DatetimeMethodEnum.TODATE)
{
return(new ReformatOpToDateTimeOffset(timeZone, timeAbacus));
}
if (method == DatetimeMethodEnum.GETDAYOFMONTH)
{
return(new ReformatOpEval <int>(CalendarEvalStatics.DAY_OF_MONTH, timeZone, timeAbacus));
}
if (method == DatetimeMethodEnum.GETMINUTEOFHOUR)
{
return(new ReformatOpEval <int>(CalendarEvalStatics.MINUTE_OF_HOUR, timeZone, timeAbacus));
}
if (method == DatetimeMethodEnum.GETMONTHOFYEAR)
{
return(new ReformatOpEval <int>(CalendarEvalStatics.MONTH_OF_YEAR, timeZone, timeAbacus));
}
if (method == DatetimeMethodEnum.GETDAYOFWEEK)
{
return(new ReformatOpEval <DayOfWeek>(CalendarEvalStatics.DAY_OF_WEEK, timeZone, timeAbacus));
}
if (method == DatetimeMethodEnum.GETDAYOFYEAR)
{
return(new ReformatOpEval <int>(CalendarEvalStatics.DAY_OF_YEAR, timeZone, timeAbacus));
}
if (method == DatetimeMethodEnum.GETERA)
{
return(new ReformatOpEval <int>(CalendarEvalStatics.ERA, timeZone, timeAbacus));
}
if (method == DatetimeMethodEnum.GETHOUROFDAY)
{
return(new ReformatOpEval <int>(CalendarEvalStatics.HOUR_OF_DAY, timeZone, timeAbacus));
}
if (method == DatetimeMethodEnum.GETMILLISOFSECOND)
{
return(new ReformatOpEval <int>(CalendarEvalStatics.MILLIS_OF_SECOND, timeZone, timeAbacus));
}
if (method == DatetimeMethodEnum.GETSECONDOFMINUTE)
{
return(new ReformatOpEval <int>(CalendarEvalStatics.SECOND_OF_MINUTE, timeZone, timeAbacus));
}
if (method == DatetimeMethodEnum.GETWEEKYEAR)
{
return(new ReformatOpEval <int>(CalendarEvalStatics.WEEKYEAR, timeZone, timeAbacus));
}
if (method == DatetimeMethodEnum.GETYEAR)
{
return(new ReformatOpEval <int>(CalendarEvalStatics.YEAR, timeZone, timeAbacus));
}
if (method == DatetimeMethodEnum.BETWEEN)
{
if (ExprNodeUtility.IsAllConstants(parameters))
{
return(new ReformatOpBetweenConstantParams(parameters, timeZone));
}
return(new ReformatOpBetweenNonConstantParams(parameters, timeZone));
}
throw new IllegalStateException("Unrecognized date-time method code '" + method + "'");
}
