public override EventBean[] ProcessUpdate(FAFQueryMethodIUDUpdate update)
{
TableEvalLockUtil.ObtainLockUnless(
instance.TableLevelRWLock.WriteLock,
instance.AgentInstanceContext.TableExprEvaluatorContext);
var events = SnapshotAndApplyFilter(
update.QueryGraph,
update.Annotations,
update.OptionalWhereClause,
instance.AgentInstanceContext);
if (events != null && events.IsEmpty()) {
return CollectionUtil.EVENTBEANARRAY_EMPTY;
}
var eventsPerStream = new EventBean[3];
if (events == null) {
update.TableUpdateStrategy.UpdateTable(
instance.EventCollection,
instance,
eventsPerStream,
instance.AgentInstanceContext);
}
else {
update.TableUpdateStrategy.UpdateTable(
events,
instance,
eventsPerStream,
instance.AgentInstanceContext);
}
return CollectionUtil.EVENTBEANARRAY_EMPTY;
}
public void ApplyLeave(
EventBean[] eventsPerStream,
object groupByKey,
ExprEvaluatorContext exprEvaluatorContext)
{
// acquire tableInstance-level write lock
TableEvalLockUtil.ObtainLockUnless(tableInstance.TableLevelRWLock.WriteLock, exprEvaluatorContext);
ApplyLeaveInternal(eventsPerStream, groupByKey, exprEvaluatorContext);
}
public override EventBean[] ProcessInsert(FAFQueryMethodIUDInsertInto insert)
{
TableEvalLockUtil.ObtainLockUnless(
instance.TableLevelRWLock.WriteLock,
instance.AgentInstanceContext.TableExprEvaluatorContext);
var theEvent = insert.InsertHelper.Process(new EventBean[0], true, true, instance.AgentInstanceContext);
var aggs = instance.Table.AggregationRowFactory.Make();
((object[]) theEvent.Underlying)[0] = aggs;
instance.AddEvent(theEvent);
return CollectionUtil.EVENTBEANARRAY_EMPTY;
}
public override ICollection<EventBean> SnapshotBestEffort(
QueryGraph queryGraph,
Attribute[] annotations)
{
TableEvalLockUtil.ObtainLockUnless(instance.TableLevelRWLock.ReadLock, instance.AgentInstanceContext);
var events = SnapshotNullWhenNoIndex(queryGraph, annotations, null, null);
if (events != null) {
return events;
}
return instance.EventCollection;
}
private ICollection<EventBean> LookupInternal(
EventBean[] events,
ExprEvaluatorContext context)
{
TableEvalLockUtil.ObtainLockUnless(_lock, context);
var result = _inner.Lookup(events, context);
if (result == null) {
return Collections.GetEmptyList<EventBean>();
}
return result;
}
protected ObjectArrayBackedEventBean GetRow(
EventBean[] eventsPerStream,
bool isNewData,
ExprEvaluatorContext context)
{
var groupKey = _factory.GroupKeyEval.Evaluate(eventsPerStream, isNewData, context);
var tableAndLockGrouped = _provider.Get();
TableEvalLockUtil.ObtainLockUnless(tableAndLockGrouped.Lock, context);
if (groupKey is object[]) {
groupKey = tableAndLockGrouped.Grouped.Table.PrimaryKeyObjectArrayTransform.From((object[]) groupKey);
}
return tableAndLockGrouped.Grouped.GetRowForGroupKey(groupKey);
}
public EventBean GetEventBean(
int column,
EventBean[] eventsPerStream,
bool isNewData,
ExprEvaluatorContext context)
{
// acquire table-level write lock
TableEvalLockUtil.ObtainLockUnless(tableInstance.TableLevelRWLock.WriteLock, context);
var @event = tableInstance.EventUngrouped;
if (@event == null) {
return null;
}
var row = ExprTableEvalStrategyUtil.GetRow(@event);
return row.GetEventBean(column, eventsPerStream, isNewData, context);
}
private ICollection<EventBean> LookupInternal(ExprEvaluatorContext context)
{
TableEvalLockUtil.ObtainLockUnless(_tableLevelLock, context);
IEnumerator<EventBean> enumerator = _contents.GetEnumerator();
if (!enumerator.MoveNext()) {
return null;
}
var result = new ArrayDeque<EventBean>();
do {
EventBean eventBean = enumerator.Current;
result.Add(eventBean);
} while (enumerator.MoveNext());
return result;
}
private void Route(
EventBean[] events,
ExprEvaluatorContext exprEvaluatorContext)
{
foreach (var routed in events) {
if (routed is NaturalEventBean) {
var natural = (NaturalEventBean) routed;
if (_audit) {
_agentInstanceContext.AuditProvider.Insert(natural.OptionalSynthetic, _agentInstanceContext);
}
if (_tableInstance != null) {
TableEvalLockUtil.ObtainLockUnless(
_tableInstance.TableLevelRWLock.WriteLock,
exprEvaluatorContext);
_tableInstance.AddEventUnadorned(natural.OptionalSynthetic);
}
else {
_agentInstanceContext.InternalEventRouter.Route(
natural.OptionalSynthetic,
_agentInstanceContext,
_parent.IsAddToFront);
}
}
else {
if (_audit) {
_agentInstanceContext.AuditProvider.Insert(routed, _agentInstanceContext);
}
if (_tableInstance != null) {
TableEvalLockUtil.ObtainLockUnless(
_tableInstance.TableLevelRWLock.WriteLock,
exprEvaluatorContext);
_tableInstance.AddEventUnadorned(routed);
}
else {
_agentInstanceContext.InternalEventRouter.Route(
routed,
_agentInstanceContext,
_parent.IsAddToFront);
}
}
}
}
public override EventBean[] ProcessDelete(FAFQueryMethodIUDDelete delete)
{
TableEvalLockUtil.ObtainLockUnless(
instance.TableLevelRWLock.WriteLock,
instance.AgentInstanceContext.TableExprEvaluatorContext);
if (delete.OptionalWhereClause == null) {
instance.ClearInstance();
return CollectionUtil.EVENTBEANARRAY_EMPTY;
}
var found = SnapshotAndApplyFilter(
delete.QueryGraph,
delete.Annotations,
delete.OptionalWhereClause,
instance.AgentInstanceContext);
foreach (var @event in found) {
instance.DeleteEvent(@event);
}
return CollectionUtil.EVENTBEANARRAY_EMPTY;
}
public void ApplyLeave(
EventBean[] eventsPerStream,
object optionalGroupKeyPerRow,
ExprEvaluatorContext exprEvaluatorContext)
{
// acquire table-level write lock
TableEvalLockUtil.ObtainLockUnless(tableInstance.TableLevelRWLock.WriteLock, exprEvaluatorContext);
var @event = tableInstance.GetCreateRowIntoTable(exprEvaluatorContext);
var row = ExprTableEvalStrategyUtil.GetRow(@event);
for (var i = 0; i < methodPairs.Length; i++) {
var methodPair = methodPairs[i];
var columnResult = methodPair.Evaluator.Evaluate(eventsPerStream, false, exprEvaluatorContext);
row.LeaveAgg(methodPair.Column, columnResult);
}
for (var i = 0; i < accessAgents.Length; i++) {
accessAgents[i].ApplyLeave(eventsPerStream, exprEvaluatorContext, row, accessColumnsZeroOffset[i]);
}
tableInstance.HandleRowUpdated(@event);
}
protected ObjectArrayBackedEventBean LockTableReadAndGet(ExprEvaluatorContext context)
{
var pair = _provider.Get();
TableEvalLockUtil.ObtainLockUnless(pair.Lock, context);
return pair.Ungrouped.EventUngrouped;
}
protected TableInstanceGrouped LockTableRead(ExprEvaluatorContext context) {
var tableAndLockGrouped = _provider.Get();
TableEvalLockUtil.ObtainLockUnless(tableAndLockGrouped.Lock, context);
return tableAndLockGrouped.Grouped;
}
