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 }));
}
