private void ReadCompare(String[] variables, Object value) { _service.SetLocalVersion(); for (int i = 0; i < variables.Length; i++) { Assert.AreEqual(value, _service.GetReader(variables[i], 0).Value); } }
private void ProcessHandleMultiple(EPStatementAgentInstanceHandle handle, IDictionary <NamedWindowConsumerView, NamedWindowDeltaData> deltaPerConsumer) { if (InstrumentationHelper.ENABLED) { InstrumentationHelper.Get().QNamedWindowCPMulti(_exceptionHandlingService.EngineURI, deltaPerConsumer, handle, _schedulingService.Time); } try { using (handle.StatementAgentInstanceLock.AcquireWriteLock()) { try { if (handle.HasVariables) { _variableService.SetLocalVersion(); } foreach (var entryDelta in deltaPerConsumer) { var newData = entryDelta.Value.NewData; var oldData = entryDelta.Value.OldData; entryDelta.Key.Update(newData, oldData); } // internal join processing, if applicable handle.InternalDispatch(); } catch (Exception ex) { _exceptionHandlingService.HandleException(ex, handle, ExceptionHandlerExceptionType.PROCESS); } finally { if (handle.HasTableAccess) { _tableService.TableExprEvaluatorContext.ReleaseAcquiredLocks(); } } } } finally { if (InstrumentationHelper.ENABLED) { InstrumentationHelper.Get().ANamedWindowCPMulti(); } } }
public override bool Evaluate(EventBean theEvent) { using (EvaluatorContext.AgentInstanceLock.AcquireWriteLock()) { _variableService.SetLocalVersion(); return(EvaluatePerStream(new[] { theEvent })); } }
public int SetVersionGetMark() { lock (this) { currentMark++; variableService.SetLocalVersion(); Log.Debug(".SetVersionGetMark Thread " + Thread.CurrentThread.ManagedThreadId + " *** mark=" + currentMark + " ***"); return(currentMark); } }
public override bool Evaluate(EventBean theEvent) { if (VariableService != null) { VariableService.SetLocalVersion(); } EventBean[] eventsPerStream = _arrayPerThread.GetOrCreate(); eventsPerStream[0] = theEvent; return(EvaluatePerStream(eventsPerStream)); }
public override bool Evaluate(EventBean theEvent) { if (VariableService != null) { VariableService.SetLocalVersion(); } var eventsPerStream = new EventBean[PrototypeArray.Length]; Array.Copy(PrototypeArray, 0, eventsPerStream, 0, PrototypeArray.Length); eventsPerStream[0] = theEvent; return(base.EvaluatePerStream(eventsPerStream)); }
/// <summary> /// Evaluate the bool expression given the event as a stream zero event. /// </summary> /// <param name="theEvent">is the stream zero event (current event)</param> /// <param name="exprEvaluatorContext">The expression evaluator context.</param> /// <returns>bool result of the expression</returns> public bool Evaluate(EventBean theEvent, ExprEvaluatorContext exprEvaluatorContext) { if (_variableService != null) { _variableService.SetLocalVersion(); } EventBean[] eventsPerStream = _arrayPerThread.GetOrCreate(); eventsPerStream[0] = theEvent; try { var result = (bool?)_exprNodeEval.Evaluate(new EvaluateParams(eventsPerStream, true, exprEvaluatorContext)); return(result ?? false); } catch (Exception ex) { Log.Error("Error evaluating expression '" + _exprNode.ToExpressionStringMinPrecedenceSafe() + "': " + ex.Message, ex); return(false); } }
/// <summary> /// Write new variable values and commit, evaluating assignment expressions using the given /// events per stream. /// <para />Populates an optional map of new values if a non-null map is passed. /// </summary> /// <param name="variableService">variable service</param> /// <param name="eventsPerStream">events per stream</param> /// <param name="valuesWritten">null or an empty map to populate with written values</param> /// <param name="exprEvaluatorContext">expression evaluation context</param> public void WriteVariables(VariableService variableService, EventBean[] eventsPerStream, IDictionary <String, Object> valuesWritten, ExprEvaluatorContext exprEvaluatorContext) { ISet <String> variablesBeansCopied = null; if (!_copyMethods.IsEmpty()) { variablesBeansCopied = new HashSet <String>(); } // We obtain a write lock global to the variable space // Since expressions can contain variables themselves, these need to be unchangeable for the duration // as there could be multiple statements that do "var1 = var1 + 1". using (variableService.ReadWriteLock.AcquireWriteLock()) { try { variableService.SetLocalVersion(); var count = 0; foreach (var assignment in _assignments) { var variableMetaData = _metaData[count]; int agentInstanceId = variableMetaData.ContextPartitionName == null ? EPStatementStartMethodConst.DEFAULT_AGENT_INSTANCE_ID : exprEvaluatorContext.AgentInstanceId; var value = assignment.Evaluator.Evaluate( new EvaluateParams(eventsPerStream, true, exprEvaluatorContext)); if (_writers[count] != null) { var reader = variableService.GetReader( variableMetaData.VariableName, exprEvaluatorContext.AgentInstanceId); var current = (EventBean)reader.Value; if (current == null) { value = null; } else { var writeDesc = _writers[count]; var copy = variablesBeansCopied.Add(writeDesc.VariableName); if (copy) { var copied = _copyMethods.Get(writeDesc.Type).Copy(current); current = copied; } variableService.Write(variableMetaData.VariableNumber, agentInstanceId, current); writeDesc.Writer.Write(value, current); } } else if (variableMetaData.EventType != null) { var eventBean = _eventAdapterService.AdapterForType(value, variableMetaData.EventType); variableService.Write(variableMetaData.VariableNumber, agentInstanceId, eventBean); } else { if ((value != null) && (_mustCoerce[count])) { value = CoercerFactory.CoerceBoxed(value, variableMetaData.VariableType); } variableService.Write(variableMetaData.VariableNumber, agentInstanceId, value); } count++; if (valuesWritten != null) { valuesWritten.Put(assignment.VariableName, value); } } variableService.Commit(); } catch (Exception ex) { Log.Error("Error evaluating on-set variable expressions: " + ex.Message, ex); variableService.Rollback(); } } }
public override bool Evaluate(EventBean theEvent) { _variableService.SetLocalVersion(); return(EvaluatePerStream(new [] { theEvent })); }