public static void findLeftTupleBlocker(
BetaNode betaNode,
RightTupleMemory rtm,
ContextEntry[] contextEntry,
BetaConstraints constraints,
LeftTuple leftTuple,
FastIterator it,
PropagationContext context,
boolean useLeftMemory) {
// This method will also remove rightTuples that are from subnetwork where no leftmemory use
// used
for (RightTuple rightTuple = betaNode.getFirstRightTuple(leftTuple, rtm, null, it);
rightTuple != null; ) {
RightTuple nextRight = (RightTuple) it.next(rightTuple);
if (constraints.isAllowedCachedLeft(contextEntry, rightTuple.getFactHandle())) {
leftTuple.setBlocker(rightTuple);
if (useLeftMemory) {
rightTuple.addBlocked(leftTuple);
break;
} else if (betaNode.isRightInputIsRiaNode()) {
// If we aren't using leftMemory and the right input is a RIAN, then we must iterate and
// find all subetwork right tuples and remove them
// so we don't break
rtm.remove(rightTuple);
} else {
break;
}
}
rightTuple = nextRight;
}
}
public void execute(InternalWorkingMemory workingMemory) {
DroolsQuery query = (DroolsQuery) factHandle.getObject();
RightTupleList rightTuples = query.getResultInsertRightTupleList();
query.setResultInsertRightTupleList(
null); // null so further operations happen on a new stack element
for (RightTuple rightTuple = rightTuples.getFirst(); rightTuple != null; ) {
RightTuple tmp = (RightTuple) rightTuple.getNext();
rightTuples.remove(rightTuple);
for (LeftTuple childLeftTuple = rightTuple.firstChild;
childLeftTuple != null;
childLeftTuple = (LeftTuple) childLeftTuple.getRightParentNext()) {
node.getSinkPropagator()
.doPropagateAssertLeftTuple(
context, workingMemory, childLeftTuple, childLeftTuple.getLeftTupleSink());
}
rightTuple = tmp;
}
// @FIXME, this should work, but it's closing needed fact handles
// actually an evaluation 34 appears on the stack twice....
// if ( !node.isOpenQuery() ) {
// workingMemory.getFactHandleFactory().destroyFactHandle( this.factHandle );
// }
}
public static void dpUpdatesReorderRightMemory(BetaMemory bm, RightTupleSets srcRightTuples) {
RightTupleMemory rtm = bm.getRightTupleMemory();
for (RightTuple rightTuple = srcRightTuples.getUpdateFirst(); rightTuple != null; ) {
RightTuple next = rightTuple.getStagedNext();
if (rightTuple.getMemory() != null) {
rightTuple.setTempRightTupleMemory(rightTuple.getMemory());
rtm.remove(rightTuple);
}
rightTuple = next;
}
for (RightTuple rightTuple = srcRightTuples.getUpdateFirst(); rightTuple != null; ) {
RightTuple next = rightTuple.getStagedNext();
if (rightTuple.getTempRightTupleMemory() != null) {
rtm.add(rightTuple);
for (LeftTuple childLeftTuple = rightTuple.getFirstChild(); childLeftTuple != null; ) {
LeftTuple childNext = childLeftTuple.getRightParentNext();
childLeftTuple.reAddLeft();
childLeftTuple = childNext;
}
}
rightTuple = next;
}
}
public void execute(InternalWorkingMemory workingMemory) {
leftTuple.setLeftTupleSink(this.node);
if (leftTuple.getFirstChild() == null) {
this.node.assertLeftTuple(leftTuple, context, workingMemory);
} else {
if (retract) {
this.node
.getSinkPropagator()
.propagateRetractLeftTuple(leftTuple, context, workingMemory);
} else {
this.node
.getSinkPropagator()
.propagateModifyChildLeftTuple(leftTuple, context, workingMemory, true);
}
}
if (leftTuple.getLeftParent() == null) {
// It's not an open query, as we aren't recording parent chains, so we need to clear out
// right memory
Object node = workingMemory.getNodeMemory(this.node);
RightTupleMemory rightMemory = null;
if (node instanceof BetaMemory) {
rightMemory = ((BetaMemory) node).getRightTupleMemory();
} else if (node instanceof AccumulateMemory) {
rightMemory = ((AccumulateMemory) node).betaMemory.getRightTupleMemory();
}
final TupleStartEqualsConstraint constraint = TupleStartEqualsConstraint.getInstance();
TupleStartEqualsConstraintContextEntry contextEntry =
new TupleStartEqualsConstraintContextEntry();
contextEntry.updateFromTuple(workingMemory, leftTuple);
FastIterator rightIt = rightMemory.fastIterator();
RightTuple temp = null;
for (RightTuple rightTuple =
rightMemory.getFirst(
leftTuple, (InternalFactHandle) context.getFactHandle(), rightIt);
rightTuple != null; ) {
temp = (RightTuple) rightIt.next(rightTuple);
if (constraint.isAllowedCachedLeft(contextEntry, rightTuple.getFactHandle())) {
rightMemory.remove(rightTuple);
}
rightTuple = temp;
}
}
}
public void execute(InternalWorkingMemory workingMemory) {
DroolsQuery query = (DroolsQuery) factHandle.getObject();
RightTupleList rightTuples = query.getResultRetractRightTupleList();
query.setResultRetractRightTupleList(
null); // null so further operations happen on a new stack element
for (RightTuple rightTuple = rightTuples.getFirst(); rightTuple != null; ) {
RightTuple tmp = (RightTuple) rightTuple.getNext();
rightTuples.remove(rightTuple);
this.node
.getSinkPropagator()
.propagateRetractRightTuple(rightTuple, context, workingMemory);
rightTuple = tmp;
}
}
public static void dpUpdatesExistentialReorderRightMemory(
BetaMemory bm, BetaNode betaNode, RightTupleSets srcRightTuples) {
RightTupleMemory rtm = bm.getRightTupleMemory();
boolean resumeFromCurrent =
!(betaNode.isIndexedUnificationJoin() || rtm.getIndexType().isComparison());
// remove all the staged rightTuples from the memory before to readd them all
// this is to avoid split bucket when an updated rightTuple hasn't been moved yet
// and so it is the first entry in the wrong bucket
for (RightTuple rightTuple = srcRightTuples.getUpdateFirst(); rightTuple != null; ) {
RightTuple next = rightTuple.getStagedNext();
if (rightTuple.getMemory() != null) {
rightTuple.setTempRightTupleMemory(rightTuple.getMemory());
if (resumeFromCurrent) {
if (rightTuple.getBlocked() != null) {
// look for a non-staged right tuple first forward ...
RightTuple tempRightTuple = (RightTuple) rightTuple.getNext();
while (tempRightTuple != null && tempRightTuple.getStagedType() != LeftTuple.NONE) {
// next cannot be an updated or deleted rightTuple
tempRightTuple = (RightTuple) tempRightTuple.getNext();
}
// ... and if cannot find one try backward
if (tempRightTuple == null) {
tempRightTuple = (RightTuple) rightTuple.getPrevious();
while (tempRightTuple != null && tempRightTuple.getStagedType() != LeftTuple.NONE) {
// next cannot be an updated or deleted rightTuple
tempRightTuple = (RightTuple) tempRightTuple.getPrevious();
}
}
rightTuple.setTempNextRightTuple(tempRightTuple);
}
}
rightTuple.setTempBlocked(rightTuple.getBlocked());
rightTuple.nullBlocked();
rtm.remove(rightTuple);
}
rightTuple = next;
}
for (RightTuple rightTuple = srcRightTuples.getUpdateFirst(); rightTuple != null; ) {
RightTuple next = rightTuple.getStagedNext();
if (rightTuple.getTempRightTupleMemory() != null) {
rtm.add(rightTuple);
if (resumeFromCurrent) {
RightTuple tempRightTuple = rightTuple.getTempNextRightTuple();
if (rightTuple.getBlocked() != null
&& tempRightTuple == null
&& rightTuple.getMemory() == rightTuple.getTempRightTupleMemory()) {
// the next RightTuple was null, but current RightTuple was added back into the same
// bucket, so reset as root blocker to re-match can be attempted
rightTuple.setTempNextRightTuple(rightTuple);
}
}
for (LeftTuple childLeftTuple = rightTuple.getFirstChild(); childLeftTuple != null; ) {
LeftTuple childNext = childLeftTuple.getRightParentNext();
childLeftTuple.reAddLeft();
childLeftTuple = childNext;
}
}
rightTuple = next;
}
}
private void doRiaNode2(
InternalWorkingMemory wm,
LeftTupleSets srcTuples,
RightInputAdapterNode riaNode,
LinkedList<StackEntry> stack) {
ObjectSink[] sinks = riaNode.getSinkPropagator().getSinks();
BetaNode betaNode = (BetaNode) sinks[0];
BetaMemory bm;
Memory nodeMem = wm.getNodeMemory(betaNode);
if (NodeTypeEnums.AccumulateNode == betaNode.getType()) {
bm = ((AccumulateMemory) nodeMem).getBetaMemory();
} else {
bm = (BetaMemory) nodeMem;
}
// Build up iteration array for other sinks
BetaNode[] bns = null;
BetaMemory[] bms = null;
int length = sinks.length;
if (length > 1) {
bns = new BetaNode[sinks.length - 1];
bms = new BetaMemory[sinks.length - 1];
for (int i = 1; i < length; i++) {
bns[i - 1] = (BetaNode) sinks[i];
Memory nodeMem2 = wm.getNodeMemory(bns[i - 1]);
if (NodeTypeEnums.AccumulateNode == betaNode.getType()) {
bms[i - 1] = ((AccumulateMemory) nodeMem2).getBetaMemory();
} else {
bms[i - 1] = (BetaMemory) nodeMem2;
}
}
}
length--; // subtract one, as first is not in the array;
for (LeftTuple leftTuple = srcTuples.getInsertFirst(); leftTuple != null; ) {
LeftTuple next = leftTuple.getStagedNext();
PropagationContext pctx = leftTuple.getPropagationContext();
InternalFactHandle handle = riaNode.createFactHandle(leftTuple, pctx, wm);
RightTuple rightTuple = new RightTuple(handle, betaNode);
leftTuple.setObject(rightTuple);
rightTuple.setPropagationContext(pctx);
bm.getStagedRightTuples().addInsert(rightTuple);
if (bns != null) {
// Add peered RightTuples, they are attached to FH - unlink LeftTuples that has a peer ref
for (int i = 0; i < length; i++) {
rightTuple = new RightTuple(handle, bns[i]);
rightTuple.setPropagationContext(pctx);
bms[i].getStagedRightTuples().addInsert(rightTuple);
}
}
leftTuple.clearStaged();
leftTuple = next;
}
for (LeftTuple leftTuple = srcTuples.getDeleteFirst(); leftTuple != null; ) {
LeftTuple next = leftTuple.getStagedNext();
RightTuple rightTuple = (RightTuple) leftTuple.getObject();
RightTupleSets rightTuples = bm.getStagedRightTuples();
switch (rightTuple.getStagedType()) {
case LeftTuple.INSERT:
{
rightTuples.removeInsert(rightTuple);
break;
}
case LeftTuple.UPDATE:
{
rightTuples.removeUpdate(rightTuple);
break;
}
}
rightTuples.addDelete(rightTuple);
if (bns != null) {
// Add peered RightTuples, they are attached to FH - unlink LeftTuples that has a peer ref
for (int i = 0; i < length; i++) {
rightTuple = rightTuple.getHandleNext();
rightTuples = bms[i].getStagedRightTuples();
switch (rightTuple.getStagedType()) {
case LeftTuple.INSERT:
{
rightTuples.removeInsert(rightTuple);
break;
}
case LeftTuple.UPDATE:
{
rightTuples.removeUpdate(rightTuple);
break;
}
}
rightTuples.addDelete(rightTuple);
}
}
leftTuple.clearStaged();
leftTuple = next;
}
for (LeftTuple leftTuple = srcTuples.getUpdateFirst(); leftTuple != null; ) {
LeftTuple next = leftTuple.getStagedNext();
RightTuple rightTuple = (RightTuple) leftTuple.getObject();
RightTupleSets rightTuples = bm.getStagedRightTuples();
switch (rightTuple.getStagedType()) {
case LeftTuple.INSERT:
{
rightTuples.removeInsert(rightTuple);
break;
}
case LeftTuple.UPDATE:
{
rightTuples.removeUpdate(rightTuple);
break;
}
}
rightTuples.addUpdate(rightTuple);
if (bns != null) {
// Add peered RightTuples, they are attached to FH - unlink LeftTuples that has a peer ref
for (int i = 0; i < length; i++) {
rightTuple = rightTuple.getHandleNext();
rightTuples = bms[i].getStagedRightTuples();
switch (rightTuple.getStagedType()) {
case LeftTuple.INSERT:
{
rightTuples.removeInsert(rightTuple);
break;
}
case LeftTuple.UPDATE:
{
rightTuples.removeUpdate(rightTuple);
break;
}
}
rightTuples.addUpdate(rightTuple);
}
}
leftTuple.clearStaged();
leftTuple = next;
}
srcTuples.resetAll();
}
public void eval2(
LeftInputAdapterNode liaNode,
PathMemory rmem,
NetworkNode node,
Memory nodeMem,
SegmentMemory[] smems,
int smemIndex,
LeftTupleSets trgTuples,
InternalWorkingMemory wm,
LinkedList<StackEntry> stack,
Set<String> visitedRules,
boolean processRian,
RuleExecutor executor) {
LeftTupleSets srcTuples;
SegmentMemory smem = smems[smemIndex];
while (true) {
srcTuples = trgTuples; // previous target, is now the source
if (log.isTraceEnabled()) {
int offset = getOffset(node);
log.trace(
"{} {} {} {}", indent(offset), ++cycle, node.toString(), srcTuples.toStringSizes());
}
if (NodeTypeEnums.isTerminalNode(node)) {
TerminalNode rtn = (TerminalNode) node;
if (node.getType() == NodeTypeEnums.QueryTerminalNode) {
pQtNode.doNode((QueryTerminalNode) rtn, wm, srcTuples, stack);
} else {
pRtNode.doNode(rtn, wm, srcTuples, executor);
}
return;
} else if (NodeTypeEnums.RightInputAdaterNode == node.getType()) {
doRiaNode2(wm, srcTuples, (RightInputAdapterNode) node, stack);
return;
}
LeftTupleSets stagedLeftTuples;
if (node == smem.getTipNode() && smem.getFirst() != null) {
// we are about to process the segment tip, allow it to merge insert/update/delete clashes
// Can happen if the next segments have not yet been initialized
stagedLeftTuples = smem.getFirst().getStagedLeftTuples();
} else {
stagedLeftTuples = null;
}
LeftTupleSinkNode sink = ((LeftTupleSource) node).getSinkPropagator().getFirstLeftTupleSink();
trgTuples = new LeftTupleSets();
if (NodeTypeEnums.isBetaNode(node)) {
BetaNode betaNode = (BetaNode) node;
BetaMemory bm = null;
AccumulateMemory am = null;
if (NodeTypeEnums.AccumulateNode == node.getType()) {
am = (AccumulateMemory) nodeMem;
bm = am.getBetaMemory();
} else {
bm = (BetaMemory) nodeMem;
}
if (processRian && betaNode.isRightInputIsRiaNode()) {
// if the subnetwork is nested in this segment, it will create srcTuples containing
// peer LeftTuples, suitable for the node in the main path.
doRiaNode(
wm,
liaNode,
rmem,
srcTuples,
betaNode,
sink,
smems,
smemIndex,
nodeMem,
bm,
stack,
visitedRules,
executor);
return; // return here is doRiaNode queues the evaluation on the stack, which is necessary
// to handled nested query nodes
}
if (!bm.getDequeu().isEmpty()) {
// If there are no staged RightTuples, then process the Dequeue, popping entries, until
// another insert/expiration clash
RightTupleSets rightTuples = bm.getStagedRightTuples();
if (rightTuples.isEmpty()) {
// nothing staged, so now process the Dequeu
Deque<RightTuple> que = bm.getDequeu();
while (!que.isEmpty()) {
RightTuple rightTuple = que.peekFirst();
if (rightTuple.getPropagationContext().getType() == PropagationContext.EXPIRATION
&&
// Cannot pop an expired fact, if the insert/update has not yet been evaluated.
rightTuple.getStagedType() != LeftTuple.NONE) {
break;
}
switch (rightTuple.getPropagationContext().getType()) {
case PropagationContext.INSERTION:
case PropagationContext.RULE_ADDITION:
rightTuples.addInsert(rightTuple);
break;
case PropagationContext.MODIFICATION:
rightTuples.addUpdate(rightTuple);
break;
case PropagationContext.DELETION:
case PropagationContext.EXPIRATION:
case PropagationContext.RULE_REMOVAL:
rightTuples.addDelete(rightTuple);
break;
}
que.removeFirst();
}
}
if (!bm.getDequeu().isEmpty()) {
// The DeQue is not empty, add StackEntry for reprocessing.
StackEntry stackEntry =
new StackEntry(
liaNode,
node,
sink,
rmem,
nodeMem,
smems,
smemIndex,
trgTuples,
visitedRules,
false);
stack.add(stackEntry);
}
}
switch (node.getType()) {
case NodeTypeEnums.JoinNode:
{
pJoinNode.doNode(
(JoinNode) node, sink, bm, wm, srcTuples, trgTuples, stagedLeftTuples);
break;
}
case NodeTypeEnums.NotNode:
{
pNotNode.doNode((NotNode) node, sink, bm, wm, srcTuples, trgTuples, stagedLeftTuples);
break;
}
case NodeTypeEnums.ExistsNode:
{
pExistsNode.doNode(
(ExistsNode) node, sink, bm, wm, srcTuples, trgTuples, stagedLeftTuples);
break;
}
case NodeTypeEnums.AccumulateNode:
{
pAccNode.doNode(
(AccumulateNode) node, sink, am, wm, srcTuples, trgTuples, stagedLeftTuples);
break;
}
}
} else {
switch (node.getType()) {
case NodeTypeEnums.EvalConditionNode:
{
pEvalNode.doNode(
(EvalConditionNode) node,
(EvalMemory) nodeMem,
sink,
wm,
srcTuples,
trgTuples,
stagedLeftTuples);
break;
}
case NodeTypeEnums.FromNode:
{
pFromNode.doNode(
(FromNode) node,
(FromMemory) nodeMem,
sink,
wm,
srcTuples,
trgTuples,
stagedLeftTuples);
break;
}
case NodeTypeEnums.QueryElementNode:
{
QueryElementNodeMemory qmem = (QueryElementNodeMemory) nodeMem;
if (srcTuples.isEmpty() && qmem.getResultLeftTuples().isEmpty()) {
// no point in evaluating query element, and setting up stack, if there is nothing
// to process
break;
}
QueryElementNode qnode = (QueryElementNode) node;
if (visitedRules == Collections.<String>emptySet()) {
visitedRules = new HashSet<String>();
}
visitedRules.add(qnode.getQueryElement().getQueryName());
// result tuples can happen when reactivity occurs inside of the query, prior to
// evaluation
// we will need special behaviour to add the results again, when this query result
// resumes
trgTuples.addAll(qmem.getResultLeftTuples());
if (!srcTuples.isEmpty()) {
// only process the Query Node if there are src tuples
StackEntry stackEntry =
new StackEntry(
liaNode,
node,
sink,
rmem,
nodeMem,
smems,
smemIndex,
trgTuples,
visitedRules,
true);
stack.add(stackEntry);
pQueryNode.doNode(
qnode, (QueryElementNodeMemory) nodeMem, stackEntry, sink, wm, srcTuples);
SegmentMemory qsmem = ((QueryElementNodeMemory) nodeMem).getQuerySegmentMemory();
List<PathMemory> qrmems = qsmem.getPathMemories();
// Build the evaluation information for each 'or' branch
// Exception fo the last, place each entry on the stack, the last one evaluate now.
for (int i = qrmems.size() - 1; i >= 0; i--) {
PathMemory qrmem = qrmems.get(i);
rmem = qrmem;
smems = qrmem.getSegmentMemories();
smemIndex = 0;
smem = smems[smemIndex]; // 0
liaNode = (LeftInputAdapterNode) smem.getRootNode();
if (liaNode == smem.getTipNode()) {
// segment only has liaNode in it
// nothing is staged in the liaNode, so skip to next segment
smem = smems[++smemIndex]; // 1
node = smem.getRootNode();
nodeMem = smem.getNodeMemories().getFirst();
} else {
// lia is in shared segment, so point to next node
node = liaNode.getSinkPropagator().getFirstLeftTupleSink();
nodeMem =
smem.getNodeMemories().getFirst().getNext(); // skip the liaNode memory
}
trgTuples = smem.getStagedLeftTuples();
if (i != 0 && !trgTuples.isEmpty()) {
// All entries except the last should be placed on the stack for evaluation
// later.
stackEntry =
new StackEntry(
liaNode,
node,
null,
rmem,
nodeMem,
smems,
smemIndex,
trgTuples,
visitedRules,
false);
if (log.isTraceEnabled()) {
int offset = getOffset(stackEntry.getNode());
log.trace(
"{} ORQueue branch={} {} {}",
indent(offset),
i,
stackEntry.getNode().toString(),
trgTuples.toStringSizes());
}
stack.add(stackEntry);
}
}
processRian = true; // make sure it's reset, so ria nodes are processed
continue;
}
break;
}
case NodeTypeEnums.ConditionalBranchNode:
{
pBranchNode.doNode(
(ConditionalBranchNode) node,
(ConditionalBranchMemory) nodeMem,
sink,
wm,
srcTuples,
trgTuples,
stagedLeftTuples,
executor);
break;
}
}
}
if (node != smem.getTipNode()) {
// get next node and node memory in the segment
node = sink;
nodeMem = nodeMem.getNext();
} else {
// Reached end of segment, start on new segment.
SegmentPropagator.propagate(smem, trgTuples, wm);
smem = smems[++smemIndex];
trgTuples = smem.getStagedLeftTuples();
if (log.isTraceEnabled()) {
log.trace("Segment {}", smemIndex);
}
node = (LeftTupleSink) smem.getRootNode();
nodeMem = smem.getNodeMemories().getFirst();
}
processRian = true; // make sure it's reset, so ria nodes are processed
}
}