public BetaMemory createBetaMemory(final RuleBaseConfiguration config,

                                       final short nodeType) {

        final BetaMemory memory = new BetaMemory( config.isSequential() ? null : new LeftTupleList(),

                                                  this.createContext(),

                                                  nodeType );

        return memory;

    }

            boolean useComparisonIndex = memory.getRightTupleMemory().getIndexType().isComparison();

            RightTuple rootBlocker = useComparisonIndex ? null : (RightTuple) rightIt.next(rightTuple);

            // we must do this after we have the next in memory

            // We add to the end to give an opportunity to re-match if in same bucket

            memory.getRightTupleMemory().removeAdd( rightTuple );

        }

        public void execute(InternalWorkingMemory workingMemory) {

            DroolsQuery query = (DroolsQuery) factHandle.getObject();

            query.setResultInsertRightTupleList( null ); // null so further operations happen on a new stack element

                RightTuple tmp = (RightTuple) rightTuple.getNext();

                for ( LeftTuple childLeftTuple = rightTuple.firstChild; childLeftTuple != null; childLeftTuple = (LeftTuple) childLeftTuple.getRightParentNext() ) {

                    node.getSinkPropagator().doPropagateAssertLeftTuple( context,

                                                                         workingMemory,

                                                                         childLeftTuple,

                                                                         childLeftTuple.getLeftTupleSink() );

        }

        public void execute(InternalWorkingMemory workingMemory) {

            DroolsQuery query = (DroolsQuery) factHandle.getObject();

            query.setResultRetractRightTupleList( null ); // null so further operations happen on a new stack element

                RightTuple tmp = (RightTuple) rightTuple.getNext();

                this.node.getSinkPropagator().propagateRetractRightTuple( rightTuple,

                                                                          context,

                                                                          workingMemory );

                rightTuple = tmp;

            }

        }

        public void execute(InternalWorkingMemory workingMemory) {

            DroolsQuery query = (DroolsQuery) factHandle.getObject();

            query.setResultUpdateRightTupleList( null ); // null so further operations happen on a new stack element

                RightTuple tmp = (RightTuple) rightTuple.getNext();

                this.node.getSinkPropagator().propagateModifyChildLeftTuple( rightTuple.firstChild,

                                                                             rightTuple.firstChild.getLeftParent(),

                                                                             context,

                                                                             workingMemory,

                                                                             true );

        int bucketCount = 0;

        FastIterator it = LinkedList.fastIterator;

        for ( int i = 0, length = entries.length; i < length; i++ ) {

            if ( entries[i] != null ) {

                while ( rightTupleList != null ) {

                    if ( rightTupleList.first != null ) {

                        Entry entry = rightTupleList.first;

                        while ( entry != null ) {

                            entry = it.next( entry );

                            factCount++;

                        }

                    } else {

                        logger.info( "error : fieldIndexHashTable cannot have empty FieldIndexEntry objects" );

                    }

                    bucketCount++;

                }

            }

        }

                    // now process existing blocks, we only process existing and not new from above loop

                    boolean useComparisonIndex = rtm.getIndexType().isComparison();

                    RightTuple rootBlocker = useComparisonIndex ? null : (RightTuple) rightIt.next(rightTuple);

                    // we must do this after we have the next in memory

                    // We add to the end to give an opportunity to re-match if in same bucket

                    rtm.removeAdd(rightTuple);

                    // now process existing blocks, we only process existing and not new from above loop

                    RightTuple rootBlocker = useComparisonIndex ? null : (RightTuple) rightIt.next(rightTuple);

                    // we must do this after we have the next in memory

                    // We add to the end to give an opportunity to re-match if in same bucket

                    rtm.removeAdd(rightTuple);

                                                                            true, // this must always be true, otherwise we can't

                                                                            // find the child tuples to iterate for evaluating the dquery results

                                                                            dquery.isOpen());

               

                if ( rightTuples == null ) {

                    dquery.setResultInsertRightTupleList(rightTuples);

                    QueryResultInsertAction evalAction = new QueryResultInsertAction( context,

                                                                                      this.factHandle,

                                                                                      leftTuple,

                                                                                      this.node );

                    context.getQueue2().addFirst( evalAction );

                }

            }

        }

                leftTuples.addDelete( childLeftTuple  );

                return;

            }

            if ( rightTuples == null ) {

                query.setResultRetractRightTupleList( rightTuples );

                QueryResultRetractAction retractAction = new QueryResultRetractAction( context,

                                                                                       this.factHandle,

                                                                                       leftTuple,

                                                                                       this.node );

                context.getQueue2().addFirst( retractAction );

            }

            if ( rightTuple.getMemory() != null ) {

                throw new RuntimeException();

            }

        }