public static void doUpdatesExistentialReorderLeftMemory(
BetaMemory bm, TupleSets<LeftTuple> srcLeftTuples) {
TupleMemory ltm = bm.getLeftTupleMemory();
// sides must first be re-ordered, to ensure iteration integrity
for (LeftTuple leftTuple = srcLeftTuples.getUpdateFirst(); leftTuple != null; ) {
LeftTuple next = leftTuple.getStagedNext();
if (leftTuple.getMemory() != null) {
ltm.remove(leftTuple);
}
leftTuple = next;
}
for (LeftTuple leftTuple = srcLeftTuples.getUpdateFirst(); leftTuple != null; ) {
LeftTuple next = leftTuple.getStagedNext();
RightTuple blocker = leftTuple.getBlocker();
if (blocker == null) {
ltm.add(leftTuple);
for (LeftTuple childLeftTuple = leftTuple.getFirstChild(); childLeftTuple != null; ) {
LeftTuple childNext = childLeftTuple.getHandleNext();
childLeftTuple.reAddRight();
childLeftTuple = childNext;
}
} else if (blocker.getStagedType() != LeftTuple.NONE) {
// it's blocker is also being updated, so remove to force it to start from the beginning
blocker.removeBlocked(leftTuple);
}
leftTuple = next;
}
}
public void doLeftDeletes(
BetaMemory bm,
LeftTupleSets srcLeftTuples,
LeftTupleSets trgLeftTuples,
LeftTupleSets stagedLeftTuples) {
LeftTupleMemory ltm = bm.getLeftTupleMemory();
for (LeftTuple leftTuple = srcLeftTuples.getDeleteFirst(); leftTuple != null; ) {
LeftTuple next = leftTuple.getStagedNext();
RightTuple blocker = leftTuple.getBlocker();
if (blocker == null) {
if (leftTuple.getMemory() != null) {
// it may have been staged and never actually added
ltm.remove(leftTuple);
}
LeftTuple childLeftTuple = leftTuple.getFirstChild();
if (childLeftTuple != null) { // NotNode only has one child
childLeftTuple.setPropagationContext(leftTuple.getPropagationContext());
RuleNetworkEvaluator.deleteLeftChild(
childLeftTuple,
trgLeftTuples,
stagedLeftTuples); // no need to update pctx, as no right available, and pctx will
// exist on a parent LeftTuple anyway
}
} else {
blocker.removeBlocked(leftTuple);
}
leftTuple.clearStaged();
leftTuple = next;
}
}
public static void dpUpdatesExistentialReorderLeftMemory(
BetaMemory bm, LeftTupleSets srcLeftTuples) {
LeftTupleMemory ltm = bm.getLeftTupleMemory();
// sides must first be re-ordered, to ensure iteration integrity
for (LeftTuple leftTuple = srcLeftTuples.getUpdateFirst(); leftTuple != null; ) {
LeftTuple next = leftTuple.getStagedNext();
if (leftTuple.getMemory() != null) {
ltm.remove(leftTuple);
}
leftTuple = next;
}
for (LeftTuple leftTuple = srcLeftTuples.getUpdateFirst(); leftTuple != null; ) {
LeftTuple next = leftTuple.getStagedNext();
if (leftTuple.getBlocker() == null) {
ltm.add(leftTuple);
for (LeftTuple childLeftTuple = leftTuple.getFirstChild(); childLeftTuple != null; ) {
LeftTuple childNext = childLeftTuple.getLeftParentNext();
childLeftTuple.reAddRight();
childLeftTuple = childNext;
}
}
leftTuple = next;
}
}
public void doLeftDeletes(
FromMemory fm,
TupleSets<LeftTuple> srcLeftTuples,
TupleSets<LeftTuple> trgLeftTuples,
TupleSets<LeftTuple> stagedLeftTuples) {
BetaMemory bm = fm.getBetaMemory();
TupleMemory ltm = bm.getLeftTupleMemory();
for (LeftTuple leftTuple = srcLeftTuples.getDeleteFirst(); leftTuple != null; ) {
LeftTuple next = leftTuple.getStagedNext();
ltm.remove(leftTuple);
Map<Object, RightTuple> matches = (Map<Object, RightTuple>) leftTuple.getContextObject();
if (leftTuple.getFirstChild() != null) {
LeftTuple childLeftTuple = leftTuple.getFirstChild();
while (childLeftTuple != null) {
childLeftTuple.setPropagationContext(leftTuple.getPropagationContext());
LeftTuple nextChild = childLeftTuple.getLeftParentNext();
RuleNetworkEvaluator.unlinkAndDeleteChildLeftTuple(
childLeftTuple, trgLeftTuples, stagedLeftTuples);
childLeftTuple = nextChild;
}
}
// if matches == null, the deletion might be happening before the fact was even propagated.
// See BZ-1019473 for details.
if (matches != null) {
// @TODO (mdp) is this really necessary? won't the entire FH and RightTuple chaines just et
// GC'd?
unlinkCreatedHandles(leftTuple);
}
leftTuple.clearStaged();
leftTuple = next;
}
}
private static ProtobufMessages.NodeMemory writeQueryElementNodeMemory(
final int nodeId, final Memory memory, final InternalWorkingMemory wm) {
org.drools.core.util.Iterator<LeftTuple> it =
LeftTupleIterator.iterator(wm, ((QueryElementNodeMemory) memory).getNode());
ProtobufMessages.NodeMemory.QueryElementNodeMemory.Builder _query =
ProtobufMessages.NodeMemory.QueryElementNodeMemory.newBuilder();
for (LeftTuple leftTuple = it.next(); leftTuple != null; leftTuple = it.next()) {
InternalFactHandle handle = (InternalFactHandle) leftTuple.getObject();
FactHandle _handle =
ProtobufMessages.FactHandle.newBuilder()
.setId(handle.getId())
.setRecency(handle.getRecency())
.build();
ProtobufMessages.NodeMemory.QueryElementNodeMemory.QueryContext.Builder _context =
ProtobufMessages.NodeMemory.QueryElementNodeMemory.QueryContext.newBuilder()
.setTuple(PersisterHelper.createTuple(leftTuple))
.setHandle(_handle);
LeftTuple childLeftTuple = leftTuple.getFirstChild();
while (childLeftTuple != null) {
RightTuple rightParent = childLeftTuple.getRightParent();
_context.addResult(
ProtobufMessages.FactHandle.newBuilder()
.setId(rightParent.getFactHandle().getId())
.setRecency(rightParent.getFactHandle().getRecency())
.build());
while (childLeftTuple != null && childLeftTuple.getRightParent() == rightParent) {
// skip to the next child that has a different right parent
childLeftTuple = childLeftTuple.getLeftParentNext();
}
}
_query.addContext(_context.build());
}
return _query.getContextCount() > 0
? ProtobufMessages.NodeMemory.newBuilder()
.setNodeId(nodeId)
.setNodeType(ProtobufMessages.NodeMemory.NodeType.QUERY_ELEMENT)
.setQueryElement(_query.build())
.build()
: null;
}
public static void doUpdatesReorderLeftMemory(BetaMemory bm, TupleSets<LeftTuple> srcLeftTuples) {
TupleMemory ltm = bm.getLeftTupleMemory();
// sides must first be re-ordered, to ensure iteration integrity
for (LeftTuple leftTuple = srcLeftTuples.getUpdateFirst(); leftTuple != null; ) {
LeftTuple next = leftTuple.getStagedNext();
ltm.remove(leftTuple);
leftTuple = next;
}
for (LeftTuple leftTuple = srcLeftTuples.getUpdateFirst(); leftTuple != null; ) {
LeftTuple next = leftTuple.getStagedNext();
ltm.add(leftTuple);
for (LeftTuple childLeftTuple = leftTuple.getFirstChild(); childLeftTuple != null; ) {
LeftTuple childNext = childLeftTuple.getHandleNext();
childLeftTuple.reAddRight();
childLeftTuple = childNext;
}
leftTuple = next;
}
}
public void doRightUpdates(
NotNode notNode,
LeftTupleSink sink,
BetaMemory bm,
InternalWorkingMemory wm,
RightTupleSets srcRightTuples,
LeftTupleSets trgLeftTuples,
LeftTupleSets stagedLeftTuples) {
LeftTupleMemory ltm = bm.getLeftTupleMemory();
RightTupleMemory rtm = bm.getRightTupleMemory();
ContextEntry[] contextEntry = bm.getContext();
BetaConstraints constraints = notNode.getRawConstraints();
boolean iterateFromStart =
notNode.isIndexedUnificationJoin() || rtm.getIndexType().isComparison();
for (RightTuple rightTuple = srcRightTuples.getUpdateFirst(); rightTuple != null; ) {
RightTuple next = rightTuple.getStagedNext();
PropagationContext context = rightTuple.getPropagationContext();
constraints.updateFromFactHandle(contextEntry, wm, rightTuple.getFactHandle());
FastIterator leftIt = notNode.getLeftIterator(ltm);
LeftTuple firstLeftTuple = notNode.getFirstLeftTuple(rightTuple, ltm, context, leftIt);
LeftTuple firstBlocked = rightTuple.getTempBlocked();
// first process non-blocked tuples, as we know only those ones are in the left memory.
for (LeftTuple leftTuple = firstLeftTuple; leftTuple != null; ) {
// preserve next now, in case we remove this leftTuple
LeftTuple temp = (LeftTuple) leftIt.next(leftTuple);
if (leftTuple.getStagedType() == LeftTuple.UPDATE) {
// ignore, as it will get processed via left iteration. Children cannot be processed twice
leftTuple = temp;
continue;
}
// we know that only unblocked LeftTuples are still in the memory
if (constraints.isAllowedCachedRight(contextEntry, leftTuple)) {
leftTuple.setBlocker(rightTuple);
rightTuple.addBlocked(leftTuple);
// this is now blocked so remove from memory
ltm.remove(leftTuple);
LeftTuple childLeftTuple = leftTuple.getFirstChild();
if (childLeftTuple != null) {
childLeftTuple.setPropagationContext(rightTuple.getPropagationContext());
RuleNetworkEvaluator.deleteRightChild(childLeftTuple, trgLeftTuples, stagedLeftTuples);
}
}
leftTuple = temp;
}
if (firstBlocked != null) {
RightTuple rootBlocker = rightTuple.getTempNextRightTuple();
if (rootBlocker == null) {
iterateFromStart = true;
}
FastIterator rightIt = notNode.getRightIterator(rtm);
// iterate all the existing previous blocked LeftTuples
for (LeftTuple leftTuple = firstBlocked; leftTuple != null; ) {
LeftTuple temp = leftTuple.getBlockedNext();
leftTuple.clearBlocker();
if (leftTuple.getStagedType() == LeftTuple.UPDATE) {
// ignore, as it will get processed via left iteration. Children cannot be processed
// twice
// but need to add it back into list first
leftTuple.setBlocker(rightTuple);
rightTuple.addBlocked(leftTuple);
leftTuple = temp;
continue;
}
constraints.updateFromTuple(contextEntry, wm, leftTuple);
if (iterateFromStart) {
rootBlocker = notNode.getFirstRightTuple(leftTuple, rtm, null, rightIt);
}
// we know that older tuples have been checked so continue next
for (RightTuple newBlocker = rootBlocker;
newBlocker != null;
newBlocker = (RightTuple) rightIt.next(newBlocker)) {
// cannot select a RightTuple queued in the delete list
// There may be UPDATE RightTuples too, but that's ok. They've already been re-added to
// the correct bucket, safe to be reprocessed.
if (leftTuple.getStagedType() != LeftTuple.DELETE
&& newBlocker.getStagedType() != LeftTuple.DELETE
&& constraints.isAllowedCachedLeft(contextEntry, newBlocker.getFactHandle())) {
leftTuple.setBlocker(newBlocker);
newBlocker.addBlocked(leftTuple);
break;
}
}
if (leftTuple.getBlocker() == null) {
// was previous blocked and not in memory, so add
ltm.add(leftTuple);
// subclasses like ForallNotNode might override this propagation
trgLeftTuples.addInsert(
sink.createLeftTuple(leftTuple, sink, rightTuple.getPropagationContext(), true));
}
leftTuple = temp;
}
}
rightTuple.clearStaged();
rightTuple = next;
}
constraints.resetFactHandle(contextEntry);
constraints.resetTuple(contextEntry);
}
public void doLeftUpdates(
NotNode notNode,
LeftTupleSink sink,
BetaMemory bm,
InternalWorkingMemory wm,
LeftTupleSets srcLeftTuples,
LeftTupleSets trgLeftTuples,
LeftTupleSets stagedLeftTuples) {
LeftTupleMemory ltm = bm.getLeftTupleMemory();
RightTupleMemory rtm = bm.getRightTupleMemory();
ContextEntry[] contextEntry = bm.getContext();
BetaConstraints constraints = notNode.getRawConstraints();
boolean leftUpdateOptimizationAllowed = notNode.isLeftUpdateOptimizationAllowed();
for (LeftTuple leftTuple = srcLeftTuples.getUpdateFirst(); leftTuple != null; ) {
LeftTuple next = leftTuple.getStagedNext();
FastIterator rightIt = notNode.getRightIterator(rtm);
RightTuple firstRightTuple = notNode.getFirstRightTuple(leftTuple, rtm, null, rightIt);
// If in memory, remove it, because we'll need to add it anyway if it's not blocked, to ensure
// iteration order
RightTuple blocker = leftTuple.getBlocker();
if (blocker == null) {
if (leftTuple.getMemory()
!= null) { // memory can be null, if blocker was deleted in same do loop
ltm.remove(leftTuple);
}
} else {
// check if we changed bucket
if (rtm.isIndexed() && !rightIt.isFullIterator()) {
// if newRightTuple is null, we assume there was a bucket change and that bucket is empty
if (firstRightTuple == null || firstRightTuple.getMemory() != blocker.getMemory()) {
blocker.removeBlocked(leftTuple);
blocker = null;
}
}
}
constraints.updateFromTuple(contextEntry, wm, leftTuple);
if (!leftUpdateOptimizationAllowed && blocker != null) {
blocker.removeBlocked(leftTuple);
blocker = null;
}
// if we where not blocked before (or changed buckets), or the previous blocker no longer
// blocks, then find the next blocker
if (blocker == null
|| !constraints.isAllowedCachedLeft(contextEntry, blocker.getFactHandle())) {
if (blocker != null) {
// remove previous blocker if it exists, as we know it doesn't block any more
blocker.removeBlocked(leftTuple);
}
// find first blocker, because it's a modify, we need to start from the beginning again
for (RightTuple newBlocker = firstRightTuple;
newBlocker != null;
newBlocker = (RightTuple) rightIt.next(newBlocker)) {
if (constraints.isAllowedCachedLeft(contextEntry, newBlocker.getFactHandle())) {
leftTuple.setBlocker(newBlocker);
newBlocker.addBlocked(leftTuple);
break;
}
}
LeftTuple childLeftTuple = leftTuple.getFirstChild();
if (leftTuple.getBlocker() != null) {
// blocked
if (childLeftTuple != null) {
// blocked, with previous children, so must have not been previously blocked, so retract
// no need to remove, as we removed at the start
// to be matched against, as it's now blocked
childLeftTuple.setPropagationContext(
leftTuple
.getBlocker()
.getPropagationContext()); // we have the righttuple, so use it for the pctx
RuleNetworkEvaluator.deleteLeftChild(childLeftTuple, trgLeftTuples, stagedLeftTuples);
} // else: it's blocked now and no children so blocked before, thus do nothing
} else if (childLeftTuple == null) {
// not blocked, with no children, must have been previously blocked so assert
ltm.add(leftTuple); // add to memory so other fact handles can attempt to match
trgLeftTuples.addInsert(
sink.createLeftTuple(
leftTuple,
sink,
leftTuple.getPropagationContext(),
true)); // use leftTuple for the pctx here, as the right one is not available
// this won't cause a problem, as the trigger tuple (to the left) will be more recent
// anwyay
} else {
updateChildLeftTuple(childLeftTuple, stagedLeftTuples, trgLeftTuples);
// not blocked, with children, so wasn't previous blocked and still isn't so modify
ltm.add(leftTuple); // add to memory so other fact handles can attempt to match
childLeftTuple.reAddLeft();
}
}
leftTuple.clearStaged();
leftTuple = next;
}
constraints.resetTuple(contextEntry);
}
public void doRightInserts(
NotNode notNode,
BetaMemory bm,
InternalWorkingMemory wm,
RightTupleSets srcRightTuples,
LeftTupleSets trgLeftTuples,
LeftTupleSets stagedLeftTuples) {
LeftTupleMemory ltm = bm.getLeftTupleMemory();
RightTupleMemory rtm = bm.getRightTupleMemory();
ContextEntry[] contextEntry = bm.getContext();
BetaConstraints constraints = notNode.getRawConstraints();
// this must be processed here, rather than initial insert, as we need to link the blocker
unlinkNotNodeOnRightInsert(notNode, bm, wm);
for (RightTuple rightTuple = srcRightTuples.getInsertFirst(); rightTuple != null; ) {
RightTuple next = rightTuple.getStagedNext();
rtm.add(rightTuple);
if (ltm == null || ltm.size() == 0) {
// do nothing here, as no left memory
rightTuple.clearStaged();
rightTuple = next;
continue;
}
FastIterator it = notNode.getLeftIterator(ltm);
PropagationContext context = rightTuple.getPropagationContext();
constraints.updateFromFactHandle(contextEntry, wm, rightTuple.getFactHandle());
for (LeftTuple leftTuple = notNode.getFirstLeftTuple(rightTuple, ltm, context, it);
leftTuple != null; ) {
// preserve next now, in case we remove this leftTuple
LeftTuple temp = (LeftTuple) it.next(leftTuple);
if (leftTuple.getStagedType() == LeftTuple.UPDATE) {
// ignore, as it will get processed via left iteration. Children cannot be processed twice
leftTuple = temp;
continue;
}
// we know that only unblocked LeftTuples are still in the memory
if (constraints.isAllowedCachedRight(contextEntry, leftTuple)) {
leftTuple.setBlocker(rightTuple);
rightTuple.addBlocked(leftTuple);
// this is now blocked so remove from memory
ltm.remove(leftTuple);
// subclasses like ForallNotNode might override this propagation
// ** @TODO (mdp) need to not break forall
LeftTuple childLeftTuple = leftTuple.getFirstChild();
if (childLeftTuple != null) { // NotNode only has one child
childLeftTuple.setPropagationContext(rightTuple.getPropagationContext());
RuleNetworkEvaluator.deleteLeftChild(childLeftTuple, trgLeftTuples, stagedLeftTuples);
}
}
leftTuple = temp;
}
rightTuple.clearStaged();
rightTuple = next;
}
constraints.resetFactHandle(contextEntry);
}
@Test
public void testRestract() {
final PropagationContext context =
pctxFactory.createPropagationContext(0, PropagationContext.INSERTION, null, null, null);
final StatefulKnowledgeSessionImpl workingMemory =
new StatefulKnowledgeSessionImpl(
1L, (InternalKnowledgeBase) KnowledgeBaseFactory.newKnowledgeBase());
final ClassFieldReader extractor = store.getReader(Cheese.class, "type");
final MvelConstraint constraint =
new MvelConstraintTestUtil(
"type == \"stilton\"", FieldFactory.getInstance().getFieldValue("stilton"), extractor);
final List list = new ArrayList();
final Cheese cheese1 = new Cheese("stilton", 5);
final Cheese cheese2 = new Cheese("stilton", 15);
list.add(cheese1);
list.add(cheese2);
final MockDataProvider dataProvider = new MockDataProvider(list);
final Pattern pattern = new Pattern(0, new ClassObjectType(Cheese.class));
From fromCe = new From(dataProvider);
fromCe.setResultPattern(pattern);
final ReteFromNode from =
new ReteFromNode(
3,
dataProvider,
new MockTupleSource(30),
new AlphaNodeFieldConstraint[] {constraint},
null,
true,
buildContext,
fromCe);
final MockLeftTupleSink sink = new MockLeftTupleSink(5);
from.addTupleSink(sink);
final List asserted = sink.getAsserted();
final Person person1 = new Person("xxx2", 30);
final FactHandle person1Handle = workingMemory.insert(person1);
final LeftTuple tuple = new LeftTupleImpl((DefaultFactHandle) person1Handle, from, true);
from.assertLeftTuple(tuple, context, workingMemory);
assertEquals(2, asserted.size());
final FromMemory memory = (FromMemory) workingMemory.getNodeMemory(from);
assertEquals(1, memory.getBetaMemory().getLeftTupleMemory().size());
assertNull(memory.getBetaMemory().getRightTupleMemory());
RightTuple rightTuple2 = tuple.getFirstChild().getRightParent();
RightTuple rightTuple1 = tuple.getFirstChild().getHandleNext().getRightParent();
assertFalse(rightTuple1.equals(rightTuple2));
assertNull(tuple.getFirstChild().getHandleNext().getHandleNext());
final InternalFactHandle handle2 = rightTuple2.getFactHandle();
final InternalFactHandle handle1 = rightTuple1.getFactHandle();
assertEquals(handle1.getObject(), cheese2);
assertEquals(handle2.getObject(), cheese1);
from.retractLeftTuple(tuple, context, workingMemory);
assertEquals(0, memory.getBetaMemory().getLeftTupleMemory().size());
assertNull(memory.getBetaMemory().getRightTupleMemory());
}
