public CalendarForgeRound(
DateTimeFieldEnum field,
DateTimeMethodEnum method)
{
this.field = field;
this.method = method;
}
public FilterExprAnalyzerAffector GetFilterDesc(
EventType[] typesPerStream,
DateTimeMethodEnum currentMethod,
IList<ExprNode> currentParameters,
ExprDotNodeFilterAnalyzerInput inputDesc)
{
return null;
}
public DatetimeMethodDesc(
DateTimeMethodEnum datetimeMethod,
DatetimeMethodProviderForgeFactory forgeFactory,
DotMethodFP[] parameters)
{
_datetimeMethod = datetimeMethod;
_forgeFactory = forgeFactory;
_parameters = parameters;
}
/// <summary>
/// Obtain information used by filter analyzer to handle this dot-method invocation as part of query planning/indexing.
/// </summary>
/// <param name="typesPerStream">event types</param>
/// <param name="currentMethod">current method</param>
/// <param name="currentParameters">current params</param>
/// <param name="inputDesc">descriptor of what the input to this interval method is</param>
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;
var targetType = typesPerStream[targetStreamNum];
targetPropertyStart = targetType.StartTimestampPropertyName;
targetPropertyEnd = targetType.EndTimestampPropertyName != null
? 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 IntervalForge GetForge(
StreamTypeService streamTypeService,
DateTimeMethodEnum method,
string methodNameUsed,
IList<ExprNode> parameters,
TimeAbacus timeAbacus,
TableCompileTimeResolver tableCompileTimeResolver)
{
return new IntervalForgeImpl(
method,
methodNameUsed,
streamTypeService,
parameters,
timeAbacus,
tableCompileTimeResolver);
}
public CalendarForge GetOp(
DateTimeMethodEnum method,
string methodNameUsed,
IList<ExprNode> parameters,
ExprForge[] forges)
{
if (method == DateTimeMethodEnum.WITHTIME) {
return new CalendarWithTimeForge(forges[0], forges[1], forges[2], forges[3]);
}
if (method == DateTimeMethodEnum.WITHDATE) {
return new CalendarWithDateForge(forges[0], forges[1], forges[2]);
}
if (method == DateTimeMethodEnum.PLUS || method == DateTimeMethodEnum.MINUS) {
return new CalendarPlusMinusForge(forges[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) {
DateTimeFieldEnum fieldNum = CalendarOpUtil.GetEnum(methodNameUsed, parameters[0]);
if (method == DateTimeMethodEnum.WITHMIN) {
return new CalendarWithMinForge(fieldNum);
}
if (method == DateTimeMethodEnum.ROUNDCEILING ||
method == DateTimeMethodEnum.ROUNDFLOOR ||
method == DateTimeMethodEnum.ROUNDHALF) {
return new CalendarForgeRound(fieldNum, method);
}
if (method == DateTimeMethodEnum.SET) {
return new CalendarSetForge(fieldNum, forges[1]);
}
return new CalendarWithMaxForge(fieldNum);
}
throw new IllegalStateException("Unrecognized calendar-op code '" + method + "'");
}
public FilterExprAnalyzerDTIntervalAffector(
DateTimeMethodEnum currentMethod,
EventType[] typesPerStream,
int targetStreamNum,
string targetStartProp,
string targetEndProp,
int parameterStreamNum,
string parameterStartProp,
string parameterEndProp)
{
this.currentMethod = currentMethod;
this.typesPerStream = typesPerStream;
this.targetStreamNum = targetStreamNum;
this.targetStartProp = targetStartProp;
this.targetEndProp = targetEndProp;
this.parameterStreamNum = parameterStreamNum;
this.parameterStartProp = parameterStartProp;
this.parameterEndProp = parameterEndProp;
}
public CalendarForge GetOp(
DatetimeMethodDesc desc,
string methodNameUsed,
IList<ExprNode> parameters,
ExprForge[] forges)
{
DateTimeMethodEnum method = desc.DatetimeMethod;
switch (method) {
case DateTimeMethodEnum.WITHTIME:
return new CalendarWithTimeForge(forges[0], forges[1], forges[2], forges[3]);
case DateTimeMethodEnum.WITHDATE:
return new CalendarWithDateForge(forges[0], forges[1], forges[2]);
case DateTimeMethodEnum.PLUS:
case DateTimeMethodEnum.MINUS:
return new CalendarPlusMinusForge(forges[0], method == DateTimeMethodEnum.MINUS ? -1 : 1);
case DateTimeMethodEnum.WITHMAX:
case DateTimeMethodEnum.WITHMIN:
case DateTimeMethodEnum.ROUNDCEILING:
case DateTimeMethodEnum.ROUNDFLOOR:
case DateTimeMethodEnum.ROUNDHALF:
case DateTimeMethodEnum.SET: {
var fieldNum = CalendarOpUtil.GetEnum(methodNameUsed, parameters[0]);
return method switch {
DateTimeMethodEnum.WITHMIN => new CalendarWithMinForge(fieldNum),
DateTimeMethodEnum.ROUNDCEILING => new CalendarForgeRound(fieldNum, method),
DateTimeMethodEnum.ROUNDFLOOR => new CalendarForgeRound(fieldNum, method),
DateTimeMethodEnum.ROUNDHALF => new CalendarForgeRound(fieldNum, method),
DateTimeMethodEnum.SET => new CalendarSetForge(fieldNum, forges[1]),
_ => new CalendarWithMaxForge(fieldNum)
};
}
default:
throw new IllegalStateException("Unrecognized calendar-op code '" + method + "'");
}
}
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 static ForgeFactory GetForgeFactory(this DateTimeMethodEnum value)
{
switch (value)
{
case DateTimeMethodEnum.WITHTIME:
return DatetimeMethodEnumStatics.CALENDAR_FORGE_FACTORY;
case DateTimeMethodEnum.WITHDATE:
return DatetimeMethodEnumStatics.CALENDAR_FORGE_FACTORY;
case DateTimeMethodEnum.PLUS:
return DatetimeMethodEnumStatics.CALENDAR_FORGE_FACTORY;
case DateTimeMethodEnum.MINUS:
return DatetimeMethodEnumStatics.CALENDAR_FORGE_FACTORY;
case DateTimeMethodEnum.WITHMAX:
return DatetimeMethodEnumStatics.CALENDAR_FORGE_FACTORY;
case DateTimeMethodEnum.WITHMIN:
return DatetimeMethodEnumStatics.CALENDAR_FORGE_FACTORY;
case DateTimeMethodEnum.SET:
return DatetimeMethodEnumStatics.CALENDAR_FORGE_FACTORY;
case DateTimeMethodEnum.ROUNDCEILING:
return DatetimeMethodEnumStatics.CALENDAR_FORGE_FACTORY;
case DateTimeMethodEnum.ROUNDFLOOR:
return DatetimeMethodEnumStatics.CALENDAR_FORGE_FACTORY;
case DateTimeMethodEnum.ROUNDHALF:
return DatetimeMethodEnumStatics.CALENDAR_FORGE_FACTORY;
case DateTimeMethodEnum.GET:
return DatetimeMethodEnumStatics.REFORMAT_FORGE_FACTORY;
case DateTimeMethodEnum.FORMAT:
return DatetimeMethodEnumStatics.REFORMAT_FORGE_FACTORY;
case DateTimeMethodEnum.TODATETIMEEX:
return DatetimeMethodEnumStatics.REFORMAT_FORGE_FACTORY;
case DateTimeMethodEnum.TODATETIMEOFFSET:
return DatetimeMethodEnumStatics.REFORMAT_FORGE_FACTORY;
case DateTimeMethodEnum.TODATETIME:
return DatetimeMethodEnumStatics.REFORMAT_FORGE_FACTORY;
case DateTimeMethodEnum.TOMILLISEC:
return DatetimeMethodEnumStatics.REFORMAT_FORGE_FACTORY;
case DateTimeMethodEnum.GETMINUTEOFHOUR:
return DatetimeMethodEnumStatics.REFORMAT_FORGE_FACTORY;
case DateTimeMethodEnum.GETMONTHOFYEAR:
return DatetimeMethodEnumStatics.REFORMAT_FORGE_FACTORY;
case DateTimeMethodEnum.GETDAYOFMONTH:
return DatetimeMethodEnumStatics.REFORMAT_FORGE_FACTORY;
case DateTimeMethodEnum.GETDAYOFWEEK:
return DatetimeMethodEnumStatics.REFORMAT_FORGE_FACTORY;
case DateTimeMethodEnum.GETDAYOFYEAR:
return DatetimeMethodEnumStatics.REFORMAT_FORGE_FACTORY;
case DateTimeMethodEnum.GETHOUROFDAY:
return DatetimeMethodEnumStatics.REFORMAT_FORGE_FACTORY;
case DateTimeMethodEnum.GETMILLISOFSECOND:
return DatetimeMethodEnumStatics.REFORMAT_FORGE_FACTORY;
case DateTimeMethodEnum.GETSECONDOFMINUTE:
return DatetimeMethodEnumStatics.REFORMAT_FORGE_FACTORY;
case DateTimeMethodEnum.GETWEEKYEAR:
return DatetimeMethodEnumStatics.REFORMAT_FORGE_FACTORY;
case DateTimeMethodEnum.GETYEAR:
return DatetimeMethodEnumStatics.REFORMAT_FORGE_FACTORY;
case DateTimeMethodEnum.BETWEEN:
return DatetimeMethodEnumStatics.REFORMAT_FORGE_FACTORY;
case DateTimeMethodEnum.BEFORE:
return DatetimeMethodEnumStatics.INTERVAL_FORGE_FACTORY;
case DateTimeMethodEnum.AFTER:
return DatetimeMethodEnumStatics.INTERVAL_FORGE_FACTORY;
case DateTimeMethodEnum.COINCIDES:
return DatetimeMethodEnumStatics.INTERVAL_FORGE_FACTORY;
case DateTimeMethodEnum.DURING:
return DatetimeMethodEnumStatics.INTERVAL_FORGE_FACTORY;
case DateTimeMethodEnum.INCLUDES:
return DatetimeMethodEnumStatics.INTERVAL_FORGE_FACTORY;
case DateTimeMethodEnum.FINISHES:
return DatetimeMethodEnumStatics.INTERVAL_FORGE_FACTORY;
case DateTimeMethodEnum.FINISHEDBY:
return DatetimeMethodEnumStatics.INTERVAL_FORGE_FACTORY;
case DateTimeMethodEnum.MEETS:
return DatetimeMethodEnumStatics.INTERVAL_FORGE_FACTORY;
case DateTimeMethodEnum.METBY:
return DatetimeMethodEnumStatics.INTERVAL_FORGE_FACTORY;
case DateTimeMethodEnum.OVERLAPS:
return DatetimeMethodEnumStatics.INTERVAL_FORGE_FACTORY;
case DateTimeMethodEnum.OVERLAPPEDBY:
return DatetimeMethodEnumStatics.INTERVAL_FORGE_FACTORY;
case DateTimeMethodEnum.STARTS:
return DatetimeMethodEnumStatics.INTERVAL_FORGE_FACTORY;
case DateTimeMethodEnum.STARTEDBY:
return DatetimeMethodEnumStatics.INTERVAL_FORGE_FACTORY;
default:
throw new ArgumentOutOfRangeException(nameof(value), value, null);
}
}
public static DotMethodFP[] GetFootprints(this DateTimeMethodEnum value)
{
switch (value)
{
case DateTimeMethodEnum.WITHTIME:
return DatetimeMethodEnumParams.WITHTIME;
case DateTimeMethodEnum.WITHDATE:
return DatetimeMethodEnumParams.WITHDATE;
case DateTimeMethodEnum.PLUS:
return DatetimeMethodEnumParams.PLUSMINUS;
case DateTimeMethodEnum.MINUS:
return DatetimeMethodEnumParams.PLUSMINUS;
case DateTimeMethodEnum.WITHMAX:
return DatetimeMethodEnumParams.CALFIELD;
case DateTimeMethodEnum.WITHMIN:
return DatetimeMethodEnumParams.CALFIELD;
case DateTimeMethodEnum.SET:
return DatetimeMethodEnumParams.CALFIELD_PLUS_INT;
case DateTimeMethodEnum.ROUNDCEILING:
return DatetimeMethodEnumParams.CALFIELD;
case DateTimeMethodEnum.ROUNDFLOOR:
return DatetimeMethodEnumParams.CALFIELD;
case DateTimeMethodEnum.ROUNDHALF:
return DatetimeMethodEnumParams.CALFIELD;
case DateTimeMethodEnum.GET:
return DatetimeMethodEnumParams.CALFIELD;
case DateTimeMethodEnum.FORMAT:
return DatetimeMethodEnumParams.FORMAT;
case DateTimeMethodEnum.TODATETIMEEX:
return DatetimeMethodEnumParams.NOPARAM;
case DateTimeMethodEnum.TODATETIMEOFFSET:
return DatetimeMethodEnumParams.NOPARAM;
case DateTimeMethodEnum.TODATETIME:
return DatetimeMethodEnumParams.NOPARAM;
case DateTimeMethodEnum.TOMILLISEC:
return DatetimeMethodEnumParams.NOPARAM;
case DateTimeMethodEnum.GETMINUTEOFHOUR:
return DatetimeMethodEnumParams.NOPARAM;
case DateTimeMethodEnum.GETMONTHOFYEAR:
return DatetimeMethodEnumParams.NOPARAM;
case DateTimeMethodEnum.GETDAYOFMONTH:
return DatetimeMethodEnumParams.NOPARAM;
case DateTimeMethodEnum.GETDAYOFWEEK:
return DatetimeMethodEnumParams.NOPARAM;
case DateTimeMethodEnum.GETDAYOFYEAR:
return DatetimeMethodEnumParams.NOPARAM;
case DateTimeMethodEnum.GETHOUROFDAY:
return DatetimeMethodEnumParams.NOPARAM;
case DateTimeMethodEnum.GETMILLISOFSECOND:
return DatetimeMethodEnumParams.NOPARAM;
case DateTimeMethodEnum.GETSECONDOFMINUTE:
return DatetimeMethodEnumParams.NOPARAM;
case DateTimeMethodEnum.GETWEEKYEAR:
return DatetimeMethodEnumParams.NOPARAM;
case DateTimeMethodEnum.GETYEAR:
return DatetimeMethodEnumParams.NOPARAM;
case DateTimeMethodEnum.BETWEEN:
return DatetimeMethodEnumParams.BETWEEN;
case DateTimeMethodEnum.BEFORE:
return DatetimeMethodEnumParams.INTERVAL_BEFORE_AFTER;
case DateTimeMethodEnum.AFTER:
return DatetimeMethodEnumParams.INTERVAL_BEFORE_AFTER;
case DateTimeMethodEnum.COINCIDES:
return DatetimeMethodEnumParams.INTERVAL_COINCIDES;
case DateTimeMethodEnum.DURING:
return DatetimeMethodEnumParams.INTERVAL_DURING_INCLUDES;
case DateTimeMethodEnum.INCLUDES:
return DatetimeMethodEnumParams.INTERVAL_DURING_INCLUDES;
case DateTimeMethodEnum.FINISHES:
return DatetimeMethodEnumParams.INTERVAL_FINISHES_FINISHEDBY;
case DateTimeMethodEnum.FINISHEDBY:
return DatetimeMethodEnumParams.INTERVAL_FINISHES_FINISHEDBY;
case DateTimeMethodEnum.MEETS:
return DatetimeMethodEnumParams.INTERVAL_MEETS_METBY;
case DateTimeMethodEnum.METBY:
return DatetimeMethodEnumParams.INTERVAL_MEETS_METBY;
case DateTimeMethodEnum.OVERLAPS:
return DatetimeMethodEnumParams.INTERVAL_DURING_OVERLAPS_OVERLAPBY;
case DateTimeMethodEnum.OVERLAPPEDBY:
return DatetimeMethodEnumParams.INTERVAL_DURING_OVERLAPS_OVERLAPBY;
case DateTimeMethodEnum.STARTS:
return DatetimeMethodEnumParams.INTERVAL_STARTS_STARTEDBY;
case DateTimeMethodEnum.STARTEDBY:
return DatetimeMethodEnumParams.INTERVAL_STARTS_STARTEDBY;
default:
throw new ArgumentOutOfRangeException(nameof(value), value, null);
}
}
public static string GetNameCamel(this DateTimeMethodEnum value)
{
switch (value)
{
case DateTimeMethodEnum.WITHTIME:
return "withTime";
case DateTimeMethodEnum.WITHDATE:
return "withDate";
case DateTimeMethodEnum.PLUS:
return "plus";
case DateTimeMethodEnum.MINUS:
return "minus";
case DateTimeMethodEnum.WITHMAX:
return "withMax";
case DateTimeMethodEnum.WITHMIN:
return "withMin";
case DateTimeMethodEnum.SET:
return "set";
case DateTimeMethodEnum.ROUNDCEILING:
return "roundCeiling";
case DateTimeMethodEnum.ROUNDFLOOR:
return "roundFloor";
case DateTimeMethodEnum.ROUNDHALF:
return "roundHalf";
case DateTimeMethodEnum.GET:
return "Get";
case DateTimeMethodEnum.FORMAT:
return "format";
case DateTimeMethodEnum.TODATETIMEEX:
return "toDateTimeEx";
case DateTimeMethodEnum.TODATETIMEOFFSET:
return "toDateTimeOffset";
case DateTimeMethodEnum.TODATETIME:
return "toDateTime";
case DateTimeMethodEnum.TOMILLISEC:
return "toMillisec";
case DateTimeMethodEnum.GETMINUTEOFHOUR:
return "getMinuteOfHour";
case DateTimeMethodEnum.GETMONTHOFYEAR:
return "getMonthOfYear";
case DateTimeMethodEnum.GETDAYOFMONTH:
return "getDayOfMonth";
case DateTimeMethodEnum.GETDAYOFWEEK:
return "getDayOfWeek";
case DateTimeMethodEnum.GETDAYOFYEAR:
return "getDayOfYear";
case DateTimeMethodEnum.GETHOUROFDAY:
return "getHourOfDay";
case DateTimeMethodEnum.GETMILLISOFSECOND:
return "getMillisOfSecond";
case DateTimeMethodEnum.GETSECONDOFMINUTE:
return "getSecondOfMinute";
case DateTimeMethodEnum.GETWEEKYEAR:
return "getWeekyear";
case DateTimeMethodEnum.GETYEAR:
return "getYear";
case DateTimeMethodEnum.BETWEEN:
return "between";
case DateTimeMethodEnum.BEFORE:
return "before";
case DateTimeMethodEnum.AFTER:
return "after";
case DateTimeMethodEnum.COINCIDES:
return "coincides";
case DateTimeMethodEnum.DURING:
return "during";
case DateTimeMethodEnum.INCLUDES:
return "includes";
case DateTimeMethodEnum.FINISHES:
return "finishes";
case DateTimeMethodEnum.FINISHEDBY:
return "finishedBy";
case DateTimeMethodEnum.MEETS:
return "meets";
case DateTimeMethodEnum.METBY:
return "metBy";
case DateTimeMethodEnum.OVERLAPS:
return "overlaps";
case DateTimeMethodEnum.OVERLAPPEDBY:
return "overlappedBy";
case DateTimeMethodEnum.STARTS:
return "starts";
case DateTimeMethodEnum.STARTEDBY:
return "startedBy";
default:
throw new ArgumentOutOfRangeException(nameof(value), value, null);
}
}
public static IntervalComputerForge Make(
DateTimeMethodEnum method,
IList<ExprNode> expressions,
TimeAbacus timeAbacus)
{
var parameters = GetParameters(expressions, timeAbacus);
if (method == DateTimeMethodEnum.BEFORE) {
if (parameters.Length == 0) {
return new IntervalComputerBeforeNoParamForge();
}
var pair =
IntervalStartEndParameterPairForge.FromParamsWithLongMaxEnd(parameters);
if (pair.IsConstant) {
return new IntervalComputerConstantBefore(pair);
}
return new IntervalComputerBeforeWithDeltaExprForge(pair);
}
if (method == DateTimeMethodEnum.AFTER) {
if (parameters.Length == 0) {
return new IntervalComputerAfterNoParam();
}
var pair =
IntervalStartEndParameterPairForge.FromParamsWithLongMaxEnd(parameters);
if (pair.IsConstant) {
return new IntervalComputerConstantAfter(pair);
}
return new IntervalComputerAfterWithDeltaExprForge(pair);
}
if (method == DateTimeMethodEnum.COINCIDES) {
if (parameters.Length == 0) {
return new IntervalComputerCoincidesNoParam();
}
var pair =
IntervalStartEndParameterPairForge.FromParamsWithSameEnd(parameters);
if (pair.IsConstant) {
return new IntervalComputerConstantCoincides(pair);
}
return new IntervalComputerCoincidesWithDeltaExprForge(pair);
}
if (method == DateTimeMethodEnum.DURING || method == DateTimeMethodEnum.INCLUDES) {
if (parameters.Length == 0) {
if (method == DateTimeMethodEnum.DURING) {
return new IntervalComputerDuringNoParam();
}
return new IntervalComputerIncludesNoParam();
}
var pair =
IntervalStartEndParameterPairForge.FromParamsWithSameEnd(parameters);
if (parameters.Length == 1) {
return new IntervalComputerDuringAndIncludesThresholdForge(
method == DateTimeMethodEnum.DURING,
pair.Start.Forge);
}
if (parameters.Length == 2) {
return new IntervalComputerDuringAndIncludesMinMax(
method == DateTimeMethodEnum.DURING,
pair.Start.Forge,
pair.End.Forge);
}
return new IntervalComputerDuringMinMaxStartEndForge(
method == DateTimeMethodEnum.DURING,
GetEvaluators(expressions, timeAbacus));
}
if (method == DateTimeMethodEnum.FINISHES) {
if (parameters.Length == 0) {
return new IntervalComputerFinishesNoParam();
}
ValidateConstantThreshold("finishes", parameters[0]);
return new IntervalComputerFinishesThresholdForge(parameters[0].Forge);
}
if (method == DateTimeMethodEnum.FINISHEDBY) {
if (parameters.Length == 0) {
return new IntervalComputerFinishedByNoParam();
}
ValidateConstantThreshold("finishedby", parameters[0]);
return new IntervalComputerFinishedByThresholdForge(parameters[0].Forge);
}
if (method == DateTimeMethodEnum.MEETS) {
if (parameters.Length == 0) {
return new IntervalComputerMeetsNoParam();
}
ValidateConstantThreshold("meets", parameters[0]);
return new IntervalComputerMeetsThresholdForge(parameters[0].Forge);
}
if (method == DateTimeMethodEnum.METBY) {
if (parameters.Length == 0) {
return new IntervalComputerMetByNoParam();
}
ValidateConstantThreshold("metBy", parameters[0]);
return new IntervalComputerMetByThresholdForge(parameters[0].Forge);
}
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].Forge);
}
return new IntervalComputerOverlapsAndByMinMaxForge(
method == DateTimeMethodEnum.OVERLAPS,
parameters[0].Forge,
parameters[1].Forge);
}
if (method == DateTimeMethodEnum.STARTS) {
if (parameters.Length == 0) {
return new IntervalComputerStartsNoParam();
}
ValidateConstantThreshold("starts", parameters[0]);
return new IntervalComputerStartsThresholdForge(parameters[0].Forge);
}
if (method == DateTimeMethodEnum.STARTEDBY) {
if (parameters.Length == 0) {
return new IntervalComputerStartedByNoParam();
}
ValidateConstantThreshold("startedBy", parameters[0]);
return new IntervalComputerStartedByThresholdForge(parameters[0].Forge);
}
throw new ArgumentException("Unknown datetime method '" + method + "'");
}
public IntervalForgeImpl(
DateTimeMethodEnum method,
string methodNameUse,
StreamTypeService streamTypeService,
IList<ExprNode> expressions,
TimeAbacus timeAbacus,
TableCompileTimeResolver tableCompileTimeResolver)
{
ExprForge forgeEndTimestamp = null;
Type timestampType;
if (expressions[0] is ExprStreamUnderlyingNode) {
var und = (ExprStreamUnderlyingNode) expressions[0];
parameterStreamNum = und.StreamId;
var 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);
var getter = ((EventTypeSPI) type).GetGetterSPI(parameterPropertyStart);
var getterReturnTypeBoxed = type.GetPropertyType(parameterPropertyStart).GetBoxedType();
ForgeTimestamp = new ExprEvaluatorStreamDTProp(parameterStreamNum, getter, getterReturnTypeBoxed);
if (type.EndTimestampPropertyName != null) {
parameterPropertyEnd = type.EndTimestampPropertyName;
var getterEndTimestamp =
((EventTypeSPI) type).GetGetterSPI(type.EndTimestampPropertyName);
forgeEndTimestamp = new ExprEvaluatorStreamDTProp(
parameterStreamNum,
getterEndTimestamp,
getterReturnTypeBoxed);
}
else {
parameterPropertyEnd = parameterPropertyStart;
}
}
else {
ForgeTimestamp = expressions[0].Forge;
timestampType = ForgeTimestamp.EvaluationType;
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 (!TypeHelper.IsDateTime(ForgeTimestamp.EvaluationType)) {
// ident node may represent a fragment
if (unresolvedPropertyName != null) {
var propertyDesc = ExprIdentNodeUtil.GetTypeFromStream(
streamTypeService,
unresolvedPropertyName,
false,
true,
tableCompileTimeResolver);
if (propertyDesc.First.FragmentEventType != null) {
var 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);
var getterFragment =
((EventTypeSPI) streamTypeService.EventTypes[parameterStreamNum]).GetGetterSPI(
unresolvedPropertyName);
var getterStartTimestamp =
((EventTypeSPI) type).GetGetterSPI(parameterPropertyStart);
ForgeTimestamp = new ExprEvaluatorStreamDTPropFragment(
parameterStreamNum,
getterFragment,
getterStartTimestamp);
if (type.EndTimestampPropertyName != null) {
parameterPropertyEnd = type.EndTimestampPropertyName;
var getterEndTimestamp =
((EventTypeSPI) type).GetGetterSPI(type.EndTimestampPropertyName);
forgeEndTimestamp = new ExprEvaluatorStreamDTPropFragment(
parameterStreamNum,
getterFragment,
getterEndTimestamp);
}
else {
parameterPropertyEnd = parameterPropertyStart;
}
}
}
else {
throw new ExprValidationException(
"For date-time method '" +
methodNameUse +
"' the first parameter expression returns '" +
ForgeTimestamp.EvaluationType +
"', however requires a Date, DateTimeEx, Long-type return value or event (with timestamp)");
}
}
}
var intervalComputerForge =
IntervalComputerForgeFactory.Make(method, expressions, timeAbacus);
// evaluation without end timestamp
var timestampTypeBoxed = timestampType.GetBoxedType();
if (forgeEndTimestamp == null) {
if (TypeHelper.IsSubclassOrImplementsInterface(timestampType, typeof(DateTimeEx))) {
IntervalOpForge = new IntervalOpDateTimeExForge(intervalComputerForge);
}
else if (timestampTypeBoxed == typeof(long?)) {
IntervalOpForge = new IntervalOpForgeLong(intervalComputerForge);
}
else if (timestampTypeBoxed == typeof(DateTimeOffset?)) {
IntervalOpForge = new IntervalOpDateTimeOffsetForge(intervalComputerForge);
}
else if (timestampTypeBoxed == typeof(DateTime?)) {
IntervalOpForge = new IntervalOpDateTimeForge(intervalComputerForge);
}
else {
throw new ArgumentException("Invalid interval first parameter type '" + timestampType + "'");
}
}
else {
if (TypeHelper.IsSubclassOrImplementsInterface(timestampType, typeof(DateTimeEx))) {
IntervalOpForge = new IntervalOpDateTimeExWithEndForge(intervalComputerForge, forgeEndTimestamp);
}
else if (timestampTypeBoxed == typeof(long?)) {
IntervalOpForge = new IntervalOpLongWithEndForge(intervalComputerForge, forgeEndTimestamp);
}
else if (timestampTypeBoxed == typeof(DateTimeOffset?)) {
IntervalOpForge = new IntervalOpDateTimeOffsetWithEndForge(
intervalComputerForge,
forgeEndTimestamp);
}
else if (timestampTypeBoxed == typeof(DateTime?)) {
IntervalOpForge = new IntervalOpDateTimeWithEndForge(intervalComputerForge, forgeEndTimestamp);
}
else {
throw new ArgumentException("Invalid interval first parameter type '" + timestampType + "'");
}
}
}
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);
}
public ReformatForge GetForge(
EPType inputType,
TimeAbacus timeAbacus,
DateTimeMethodEnum method,
string methodNameUsed,
IList<ExprNode> parameters,
ExprEvaluatorContext exprEvaluatorContext)
{
if (method == DateTimeMethodEnum.GET) {
var fieldNum = CalendarOpUtil.GetEnum(methodNameUsed, parameters[0]);
return new ReformatGetFieldForge(fieldNum, timeAbacus);
}
if (method == DateTimeMethodEnum.FORMAT) {
if (parameters.IsEmpty()) {
return FORMAT_STRING;
}
var formatterType = CalendarOpUtil.ValidateGetFormatterType(inputType, methodNameUsed, parameters[0]);
return new ReformatFormatForge(formatterType, parameters[0].Forge, timeAbacus);
}
if (method == DateTimeMethodEnum.TODATETIMEEX) {
return new ReformatToDateTimeExForge(timeAbacus);
}
if (method == DateTimeMethodEnum.TODATETIMEOFFSET) {
return new ReformatToDateTimeOffsetForge(timeAbacus);
}
if (method == DateTimeMethodEnum.TODATETIME) {
return new ReformatToDateTimeForge(timeAbacus);
}
if (method == DateTimeMethodEnum.TOMILLISEC) {
return new ReformatToMillisecForge();
}
if (method == DateTimeMethodEnum.GETDAYOFMONTH) {
return new ReformatEvalForge(DateTimeExEvalStatics.DAY_OF_MONTH, timeAbacus);
}
if (method == DateTimeMethodEnum.GETMINUTEOFHOUR) {
return new ReformatEvalForge(DateTimeExEvalStatics.MINUTE_OF_HOUR, timeAbacus);
}
if (method == DateTimeMethodEnum.GETMONTHOFYEAR) {
return new ReformatEvalForge(DateTimeExEvalStatics.MONTH_OF_YEAR, timeAbacus);
}
if (method == DateTimeMethodEnum.GETDAYOFWEEK) {
return new ReformatEvalForge(DateTimeExEvalStatics.DAY_OF_WEEK, timeAbacus);
}
if (method == DateTimeMethodEnum.GETDAYOFYEAR) {
return new ReformatEvalForge(DateTimeExEvalStatics.DAY_OF_YEAR, timeAbacus);
}
if (method == DateTimeMethodEnum.GETHOUROFDAY) {
return new ReformatEvalForge(DateTimeExEvalStatics.HOUR_OF_DAY, timeAbacus);
}
if (method == DateTimeMethodEnum.GETMILLISOFSECOND) {
return new ReformatEvalForge(DateTimeExEvalStatics.MILLIS_OF_SECOND, timeAbacus);
}
if (method == DateTimeMethodEnum.GETSECONDOFMINUTE) {
return new ReformatEvalForge(DateTimeExEvalStatics.SECOND_OF_MINUTE, timeAbacus);
}
if (method == DateTimeMethodEnum.GETWEEKYEAR) {
return new ReformatEvalForge(DateTimeExEvalStatics.WEEKYEAR, timeAbacus);
}
if (method == DateTimeMethodEnum.GETYEAR) {
return new ReformatEvalForge(DateTimeExEvalStatics.YEAR, timeAbacus);
}
if (method == DateTimeMethodEnum.BETWEEN) {
if (ExprNodeUtilityQuery.IsAllConstants(parameters)) {
return new ReformatBetweenConstantParamsForge(parameters);
}
return new ReformatBetweenNonConstantParamsForge(parameters);
}
throw new IllegalStateException("Unrecognized date-time method code '" + method + "'");
}
