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

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

                                                                         query.isOpen() );

            if ( rightTuples == null ) {

                query.setResultInsertRightTupleList( rightTuples );

                QueryResultInsertAction evalAction = new QueryResultInsertAction( context,

                                                                                  this.factHandle,

                                                                                  leftTuple,

                                                                                  this.node );

                context.getQueue2().addFirst( evalAction );

            }

        }

            resultLeftTuple.setObject( null );

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

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

            }

        }

            }

            // Don't need to recreate child links, as they will already be there form the first "add"

            if ( rightTuples == null ) {

                query.setResultUpdateRightTupleList( rightTuples );

                QueryResultUpdateAction updateAction = new QueryResultUpdateAction( context,

                                                                                    this.factHandle,

                                                                                    leftTuple,

                                                                                    this.node );

                context.getQueue2().addFirst( updateAction );

            }

        }

                    // 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

            FastIterator rightIt = getRightIterator( memory.getRightTupleMemory() );

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

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

        } else {

            LeftTupleList tupleHashTable = (LeftTupleList) betaMemory.getLeftTupleMemory();

            assertFalse( tupleHashTable.isIndexed() );

        }

    }

        // Construct a table with one row, containing one list, containing three entries.

        int numEntries = 3;

        RightTupleList[] table = new RightTupleList[3];

       

        table[0] = rtList;       

        for ( int i = 0; i < numEntries; i++ ) {

            RightTuple rightTuple = new RightTuple();

            rightTuple.setMemory( rtList );

        }

        table[2] = rtList;

        for ( int i = 0; i < numEntries; i++ ) {

            RightTuple rightTuple = new RightTuple();

            rightTuple.setMemory( rtList );

        }

        table[2].setNext( rtList );

        for ( int i = 0; i < numEntries; i++ ) {

            RightTuple rightTuple = new RightTuple();

            rightTuple.setMemory( rtList );

        }

        // test fast

        RightTupleIndexHashTable.FullFastIterator iter = new RightTupleIndexHashTable.FullFastIterator( table );

        List<RightTuple> list = new ArrayList<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 );

        }

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