Esempio n. 1
0
 public IntervalOpEvalCal(IntervalComputer intervalComputer)
     : base(intervalComputer)
 {
 }
Esempio n. 2
0
            public override Object Evaluate(long startTs, long endTs, Object parameter, EventBean[] eventsPerStream, bool isNewData, ExprEvaluatorContext context)
            {
                long time = parameter.AsDateTimeOffset().TimeInMillis();

                return(IntervalComputer.Compute(startTs, endTs, time, time, eventsPerStream, isNewData, context));
            }
Esempio n. 3
0
            public override Object Evaluate(long startTs, long endTs, Object parameter, EventBean[] eventsPerStream, bool isNewData, ExprEvaluatorContext context)
            {
                var time = ((long?)parameter).GetValueOrDefault();

                return(IntervalComputer.Compute(startTs, endTs, time, time, eventsPerStream, isNewData, context));
            }
Esempio n. 4
0
 public IntervalOpEvalLong(IntervalComputer intervalComputer)
     : base(intervalComputer)
 {
 }
Esempio n. 5
0
 public IntervalOpEvalDateBase(IntervalComputer intervalComputer)
 {
     IntervalComputer = intervalComputer;
 }
Esempio n. 6
0
        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 + "'");
                }
            }
        }
Esempio n. 7
0
 public IntervalOpEvalDateTimeEx(IntervalComputer intervalComputer)
     : base(intervalComputer)
 {
 }